From 8b87da1332fdfb63eac4d1674a5dbb2129ef96d7 Mon Sep 17 00:00:00 2001 From: fxy060608 Date: Fri, 25 Jun 2021 17:39:08 +0800 Subject: [PATCH] chore(types): @dcloudio/uni-platform --- packages/uni-api/src/service/base/upx2px.ts | 2 +- .../uni-api/src/service/context/canvas.ts | 2 +- .../src/service/ui/createSelectorQuery.ts | 45 +- packages/uni-app-plus/build.json | 2 +- .../uni-app-plus/dist/uni-app-service.es.js | 5108 ++++++-- .../uni-app-plus/dist/uni-app-view.umd.js | 5126 +++++++- packages/uni-app-plus/package.json | 1 + packages/uni-app-plus/src/platform/index.ts | 67 +- .../api/context/createInnerAudioContext.ts | 3 +- .../api/context/getBackgroundAudioManager.ts | 2 +- .../src/service/api/file/openDocument.ts | 2 +- .../src/service/api/media/previewImage.ts | 4 +- packages/uni-app-plus/src/service/index.ts | 3 + packages/uni-app-plus/src/view/index.ts | 3 +- packages/uni-app-plus/tsconfig.json | 9 + packages/uni-app-plus/vite.config.ts | 26 +- packages/uni-app-vue/build.json | 26 +- .../uni-app-vue/dist/service.runtime.esm.js | 10026 ++++++++++++++++ packages/uni-app-vue/dist/view.runtime.esm.js | 9934 +++++++++++++++ ....runtime.esm.js => service.runtime.esm.js} | 454 +- .../view.runtime.esm.js} | 7425 ++++++------ packages/uni-app-vue/src/index.ts | 3 - packages/uni-app-vue/src/service/index.ts | 2 + packages/uni-app-vue/src/view/index.ts | 1 + packages/uni-h5/src/platform/dom.ts | 2 +- .../service/api/ui/requestComponentInfo.ts | 36 +- packages/uni-h5/tsconfig.json | 9 + packages/uni-i18n/tsconfig.json | 3 +- packages/uni-mp-alipay/dist/uni.api.esm.js | 8 +- packages/uni-mp-alipay/src/platform/index.ts | 1 - packages/uni-mp-alipay/tsconfig.json | 12 + packages/uni-mp-baidu/dist/uni.api.esm.js | 8 +- packages/uni-mp-baidu/src/platform/index.ts | 1 - packages/uni-mp-baidu/tsconfig.json | 10 + packages/uni-mp-core/src/api/index.ts | 6 +- packages/uni-mp-core/src/api/promise.ts | 6 +- packages/uni-mp-core/src/platform/index.ts | 11 - packages/uni-mp-qq/dist/uni.api.esm.js | 8 +- packages/uni-mp-qq/src/platform/index.ts | 1 - packages/uni-mp-qq/tsconfig.json | 10 + packages/uni-mp-toutiao/dist/uni.api.esm.js | 8 +- packages/uni-mp-toutiao/src/platform/index.ts | 1 - packages/uni-mp-toutiao/tsconfig.json | 12 + packages/uni-mp-weixin/dist/uni.api.esm.js | 8 +- packages/uni-mp-weixin/src/platform/index.ts | 1 - packages/uni-mp-weixin/tsconfig.json | 12 + .../uni-quickapp-webview/dist/uni.api.esm.js | 8 +- .../src/platform/index.ts | 1 - packages/uni-quickapp-webview/tsconfig.json | 12 + packages/uni-shared/tsconfig.json | 2 + packages/vite-plugin-uni/package.json | 2 +- rollup.config.js | 83 +- tsconfig.json | 8 +- yarn.lock | 57 +- 54 files changed, 33882 insertions(+), 4741 deletions(-) create mode 100644 packages/uni-app-plus/tsconfig.json create mode 100644 packages/uni-app-vue/dist/service.runtime.esm.js create mode 100644 packages/uni-app-vue/dist/view.runtime.esm.js rename packages/uni-app-vue/lib/{vue.runtime.esm.js => service.runtime.esm.js} (96%) rename packages/uni-app-vue/{dist/vue.runtime.esm.js => lib/view.runtime.esm.js} (67%) delete mode 100644 packages/uni-app-vue/src/index.ts create mode 100644 packages/uni-app-vue/src/service/index.ts create mode 100644 packages/uni-app-vue/src/view/index.ts create mode 100644 packages/uni-h5/tsconfig.json create mode 100644 packages/uni-mp-alipay/tsconfig.json create mode 100644 packages/uni-mp-baidu/tsconfig.json delete mode 100644 packages/uni-mp-core/src/platform/index.ts create mode 100644 packages/uni-mp-qq/tsconfig.json create mode 100644 packages/uni-mp-toutiao/tsconfig.json create mode 100644 packages/uni-mp-weixin/tsconfig.json create mode 100644 packages/uni-quickapp-webview/tsconfig.json diff --git a/packages/uni-api/src/service/base/upx2px.ts b/packages/uni-api/src/service/base/upx2px.ts index 25b4ce88a..a4f4ba2de 100644 --- a/packages/uni-api/src/service/base/upx2px.ts +++ b/packages/uni-api/src/service/base/upx2px.ts @@ -16,7 +16,7 @@ function checkDeviceWidth() { const { platform, pixelRatio, windowWidth } = getBaseSystemInfo() deviceWidth = windowWidth as number deviceDPR = pixelRatio as number - isIOS = platform === 'ios' + isIOS = (platform as string) === 'ios' } function checkValue(value: unknown, defaultValue: number) { diff --git a/packages/uni-api/src/service/context/canvas.ts b/packages/uni-api/src/service/context/canvas.ts index ede4dccde..20b7c2957 100644 --- a/packages/uni-api/src/service/context/canvas.ts +++ b/packages/uni-api/src/service/context/canvas.ts @@ -458,7 +458,7 @@ export class CanvasContext implements UniApp.CanvasContext { .find((webview) => webview.getURL().endsWith('www/__uniappview.html')) if (webview) { width = Number( - webview.evalJSSync( + (webview as any).evalJSSync( `(${measureText.toString()})(${JSON.stringify( text )},${JSON.stringify(font)})` diff --git a/packages/uni-api/src/service/ui/createSelectorQuery.ts b/packages/uni-api/src/service/ui/createSelectorQuery.ts index 37249e444..7dfe30bed 100644 --- a/packages/uni-api/src/service/ui/createSelectorQuery.ts +++ b/packages/uni-api/src/service/ui/createSelectorQuery.ts @@ -6,15 +6,23 @@ import { EditorContext } from '../context/editor' import { MapContext } from '../context/createMapContext' import { VideoContext } from '../context/createVideoContext' import { requestComponentInfo } from '@dcloudio/uni-platform' +import { getContextInfo } from '@dcloudio/uni-components' type NodeField = UniApp.NodeField -type ContextType = 'canvas' | 'map' | 'video' | 'editor' -interface NodeInfo extends UniApp.NodeInfo { - contextInfo?: { - id: string - type: ContextType - page: number - } +export interface SelectorQueryNodeInfo + extends UniApp.NodeInfo, + Omit< + Partial>, + 'top' | 'bottom' | 'left' | 'right' | 'height' | 'width' + > { + contextInfo?: ReturnType +} + +export interface SelectorQueryRequest { + component: ComponentPublicInstance | undefined | null + selector: string + single: boolean + fields: NodeField } const ContextClasss = { @@ -24,9 +32,9 @@ const ContextClasss = { editor: EditorContext, } -function convertContext(result: NodeInfo | null) { +function convertContext(result: SelectorQueryNodeInfo | null) { if (result && result.contextInfo) { - const { id, type, page } = (result as NodeInfo).contextInfo! + const { id, type, page } = (result as SelectorQueryNodeInfo).contextInfo! const ContextClass = ContextClasss[type] result.context = new ContextClass(id, page) delete result.contextInfo @@ -50,7 +58,7 @@ class NodesRef implements UniApp.NodesRef { this._single = single } - boundingClientRect(callback: (result: NodeInfo) => void) { + boundingClientRect(callback: (result: SelectorQueryNodeInfo) => void) { this._selectorQuery._push( this._selector, this._component, @@ -66,7 +74,7 @@ class NodesRef implements UniApp.NodesRef { return this._selectorQuery } - fields(fields: NodeField, callback: (result: NodeInfo) => void) { + fields(fields: NodeField, callback: (result: SelectorQueryNodeInfo) => void) { this._selectorQuery._push( this._selector, this._component, @@ -77,7 +85,7 @@ class NodesRef implements UniApp.NodesRef { return this._selectorQuery } - scrollOffset(callback: (result: NodeInfo) => void) { + scrollOffset(callback: (result: SelectorQueryNodeInfo) => void) { this._selectorQuery._push( this._selector, this._component, @@ -92,7 +100,7 @@ class NodesRef implements UniApp.NodesRef { return this._selectorQuery } - context(callback: (result: NodeInfo) => void) { + context(callback: (result: SelectorQueryNodeInfo) => void) { this._selectorQuery._push( this._selector, this._component, @@ -108,12 +116,7 @@ class NodesRef implements UniApp.NodesRef { class SelectorQuery implements UniApp.SelectorQuery { private _page: ComponentPublicInstance - private _queue: Array<{ - component: ComponentPublicInstance | undefined | null - selector: string - single: boolean - fields: NodeField - }> + private _queue: Array private _component?: ComponentPublicInstance = undefined private _queueCb: any[] private _nodesRef?: NodesRef @@ -127,7 +130,7 @@ class SelectorQuery implements UniApp.SelectorQuery { requestComponentInfo( this._page, this._queue, - (res: Array) => { + (res: Array) => { const queueCbs = this._queueCb res.forEach((result, index) => { if (Array.isArray(result)) { @@ -182,7 +185,7 @@ class SelectorQuery implements UniApp.SelectorQuery { component: ComponentPublicInstance | undefined | null, single: boolean, fields: NodeField, - callback: (result: NodeInfo) => void + callback: (result: SelectorQueryNodeInfo) => void ) { this._queue.push({ component, diff --git a/packages/uni-app-plus/build.json b/packages/uni-app-plus/build.json index a5c4b54dd..6cf3c6ac9 100644 --- a/packages/uni-app-plus/build.json +++ b/packages/uni-app-plus/build.json @@ -5,7 +5,7 @@ "output": { "name": "serviceContext", "format": "iife", - "banner": "export function createServiceContext(Vue, weex, plus, UniServiceJSBridge,instanceContext){\nconst setTimeout = instanceContext.setTimeout;\nconst clearTimeout = instanceContext.clearTimeout;\nconst setInterval = instanceContext.setInterval;\nconst clearInterval = instanceContext.clearInterval;\nconst __uniConfig = instanceContext.__uniConfig;\nconst __uniRoutes = instanceContext.__uniRoutes;\n", + "banner": "export function createServiceContext(Vue, weex, plus,instanceContext){\nconst setTimeout = instanceContext.setTimeout;\nconst clearTimeout = instanceContext.clearTimeout;\nconst setInterval = instanceContext.setInterval;\nconst clearInterval = instanceContext.clearInterval;\nconst __uniConfig = instanceContext.__uniConfig;\nconst __uniRoutes = instanceContext.__uniRoutes;\n", "footer": "const uni = serviceContext.uni;\nconst getApp = serviceContext.getApp;\nconst getCurrentPages = serviceContext.getCurrentPages;\nconst __definePage = serviceContext.__definePage;\nconst __registerPage = serviceContext.__registerPage;\nreturn serviceContext;\n}" }, "external": false diff --git a/packages/uni-app-plus/dist/uni-app-service.es.js b/packages/uni-app-plus/dist/uni-app-service.es.js index 307c64b1a..1fdaffaf6 100644 --- a/packages/uni-app-plus/dist/uni-app-service.es.js +++ b/packages/uni-app-plus/dist/uni-app-service.es.js @@ -1,4 +1,4 @@ -export function createServiceContext(Vue, weex, plus, UniServiceJSBridge,instanceContext){ +export function createServiceContext(Vue, weex, plus,instanceContext){ const setTimeout = instanceContext.setTimeout; const clearTimeout = instanceContext.clearTimeout; const setInterval = instanceContext.setInterval; @@ -7,806 +7,4366 @@ const __uniConfig = instanceContext.__uniConfig; const __uniRoutes = instanceContext.__uniRoutes; var serviceContext = (function () { - 'use strict'; - - /** - * Make a map and return a function for checking if a key - * is in that map. - * IMPORTANT: all calls of this function must be prefixed with - * \/\*#\_\_PURE\_\_\*\/ - * So that rollup can tree-shake them if necessary. - */ - (process.env.NODE_ENV !== 'production') - ? Object.freeze({}) - : {}; - (process.env.NODE_ENV !== 'production') ? Object.freeze([]) : []; - const extend = Object.assign; - const isArray = Array.isArray; - const isString = (val) => typeof val === 'string'; - const objectToString = Object.prototype.toString; - const toTypeString = (value) => objectToString.call(value); - const isPlainObject = (val) => toTypeString(val) === '[object Object]'; - - let isInitEntryPage = false; - function initEntry() { - if (isInitEntryPage) { - return; - } - isInitEntryPage = true; - let entryPagePath; - let entryPageQuery; - const weexPlus = weex.requireModule('plus'); - if (weexPlus.getRedirectInfo) { - const info = weexPlus.getRedirectInfo() || {}; - entryPagePath = info.path; - entryPageQuery = info.query ? '?' + info.query : ''; - } - else { - const argsJsonStr = plus.runtime.arguments; - if (!argsJsonStr) { - return; - } - try { - const args = JSON.parse(argsJsonStr); - entryPagePath = args.path || args.pathName; - entryPageQuery = args.query ? '?' + args.query : ''; - } - catch (e) { } - } - if (!entryPagePath || entryPagePath === __uniConfig.entryPagePath) { - if (entryPageQuery) { - __uniConfig.entryPageQuery = entryPageQuery; - } - return; - } - const entryRoute = '/' + entryPagePath; - const routeOptions = __uniRoutes.find((route) => route.path === entryRoute); - if (!routeOptions) { - return; - } - if (!routeOptions.meta.isTabBar) { - __uniConfig.realEntryPagePath = - __uniConfig.realEntryPagePath || __uniConfig.entryPagePath; - } - __uniConfig.entryPagePath = entryPagePath; - __uniConfig.entryPageQuery = entryPageQuery; - } + 'use strict'; - const cacheStringFunction = (fn) => { - const cache = Object.create(null); - return ((str) => { - const hit = cache[str]; - return hit || (cache[str] = fn(str)); - }); - }; - const invokeArrayFns = (fns, arg) => { - let ret; - for (let i = 0; i < fns.length; i++) { - ret = fns[i](arg); - } - return ret; - }; - - const encode$1 = encodeURIComponent; - function stringifyQuery(obj, encodeStr = encode$1) { - const res = obj - ? Object.keys(obj) - .map((key) => { - let val = obj[key]; - if (typeof val === undefined || val === null) { - val = ''; - } - else if (isPlainObject(val)) { - val = JSON.stringify(val); - } - return encodeStr(key) + '=' + encodeStr(val); - }) - .filter((x) => x.length > 0) - .join('&') - : null; - return res ? `?${res}` : ''; - } - const TABBAR_HEIGHT = 50; - const BACKGROUND_COLOR = '#f7f7f7'; // 背景色，如标题栏默认背景色 - const SCHEME_RE = /^([a-z-]+:)?\/\//i; - const DATA_RE = /^data:.*,.*/; - const WEB_INVOKE_APPSERVICE = 'WEB_INVOKE_APPSERVICE'; - - function hasRpx(str) { - return str.indexOf('rpx') !== -1 || str.indexOf('upx') !== -1; - } - function rpx2px(str, replace = false) { - if (replace) { - return rpx2pxWithReplace(str); - } - if (typeof str === 'string') { - const res = parseInt(str) || 0; - if (hasRpx(str)) { - return uni.upx2px(res); - } - return res; - } - return str; - } - function rpx2pxWithReplace(str) { - if (!hasRpx(str)) { - return str; - } - return str.replace(/(\d+(\.\d+)?)[ru]px/g, (_a, b) => { - return uni.upx2px(parseFloat(b)) + 'px'; - }); - } + /* + * base64-arraybuffer + * https://github.com/niklasvh/base64-arraybuffer + * + * Copyright (c) 2012 Niklas von Hertzen + * Licensed under the MIT license. + */ - const PAGE_META_KEYS = ['navigationBar', 'pullToRefresh']; - function initGlobalStyle() { - return JSON.parse(JSON.stringify(__uniConfig.globalStyle || {})); - } - function mergePageMeta(id, pageMeta) { - const globalStyle = initGlobalStyle(); - const res = extend({ id }, globalStyle, pageMeta); - PAGE_META_KEYS.forEach((name) => { - res[name] = extend({}, globalStyle[name], pageMeta[name]); - }); - return res; - } - function normalizePullToRefreshRpx(pullToRefresh) { - if (pullToRefresh.offset) { - pullToRefresh.offset = rpx2px(pullToRefresh.offset); - } - if (pullToRefresh.height) { - pullToRefresh.height = rpx2px(pullToRefresh.height); - } - if (pullToRefresh.range) { - pullToRefresh.range = rpx2px(pullToRefresh.range); - } - return pullToRefresh; - } + var chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'; - function getRealRoute(fromRoute, toRoute) { - if (toRoute.indexOf('/') === 0) { - return toRoute; - } - if (toRoute.indexOf('./') === 0) { - return getRealRoute(fromRoute, toRoute.substr(2)); - } - const toRouteArray = toRoute.split('/'); - const toRouteLength = toRouteArray.length; - let i = 0; - for (; i < toRouteLength && toRouteArray[i] === '..'; i++) { - // noop - } - toRouteArray.splice(0, i); - toRoute = toRouteArray.join('/'); - const fromRouteArray = fromRoute.length > 0 ? fromRoute.split('/') : []; - fromRouteArray.splice(fromRouteArray.length - i - 1, i + 1); - return '/' + fromRouteArray.concat(toRouteArray).join('/'); + // Use a lookup table to find the index. + var lookup = /*#__PURE__*/ (function () { + const lookup = new Uint8Array(256); + for (var i = 0; i < chars.length; i++) { + lookup[chars.charCodeAt(i)] = i; } + return lookup + })(); - function getCurrentPage() { - const pages = getCurrentPages(); - const len = pages.length; - if (len) { - return pages[len - 1]; - } - } - function getCurrentPageVm() { - const page = getCurrentPage(); - if (page) { - return page.$vm; - } - } - function invokeHook(vm, name, args) { - if (isString(vm)) { - args = name; - name = vm; - vm = getCurrentPageVm(); - } - else if (typeof vm === 'number') { - const page = getCurrentPages().find((page) => page.$page.id === vm); - if (page) { - vm = page.$vm; - } - else { - vm = getCurrentPageVm(); - } - } - if (!vm) { - return; - } - const hooks = vm.$[name]; - return hooks && invokeArrayFns(hooks, args); - } + function encode$3(arraybuffer) { + var bytes = new Uint8Array(arraybuffer), + i, + len = bytes.length, + base64 = ''; - function getRealPath(filepath) { - // 无协议的情况补全 https - if (filepath.indexOf('//') === 0) { - return 'https:' + filepath; - } - // 网络资源或base64 - if (SCHEME_RE.test(filepath) || DATA_RE.test(filepath)) { - return filepath; - } - if (isSystemURL(filepath)) { - return 'file://' + normalizeLocalPath(filepath); - } - const wwwPath = 'file://' + normalizeLocalPath('_www'); - // 绝对路径转换为本地文件系统路径 - if (filepath.indexOf('/') === 0) { - // 平台绝对路径 安卓、iOS - if (filepath.startsWith('/storage/') || - filepath.includes('/Containers/Data/Application/')) { - return 'file://' + filepath; - } - return wwwPath + filepath; - } - // 相对资源 - if (filepath.indexOf('../') === 0 || filepath.indexOf('./') === 0) { - // @ts-expect-error app-view - if (typeof __id__ === 'string') { - // @ts-expect-error app-view - return wwwPath + getRealRoute('/' + __id__, filepath); - } - else { - const pages = getCurrentPages(); - if (pages.length) { - return (wwwPath + getRealRoute('/' + pages[pages.length - 1].route, filepath)); - } - } - } - return filepath; - } - const normalizeLocalPath = cacheStringFunction((filepath) => { - return plus.io - .convertLocalFileSystemURL(filepath) - .replace(/^\/?apps\//, '/android_asset/apps/') - .replace(/\/$/, ''); - }); - function isSystemURL(filepath) { - if (filepath.indexOf('_www') === 0 || - filepath.indexOf('_doc') === 0 || - filepath.indexOf('_documents') === 0 || - filepath.indexOf('_downloads') === 0) { - return true; - } - return false; + for (i = 0; i < len; i += 3) { + base64 += chars[bytes[i] >> 2]; + base64 += chars[((bytes[i] & 3) << 4) | (bytes[i + 1] >> 4)]; + base64 += chars[((bytes[i + 1] & 15) << 2) | (bytes[i + 2] >> 6)]; + base64 += chars[bytes[i + 2] & 63]; } - const isIOS = plus.os.name === 'iOS'; - let config; - /** - * tabbar显示状态 - */ - let visible = true; - let tabBar; - /** - * 设置角标 - * @param {string} type - * @param {number} index - * @param {string} text - */ - function setTabBarBadge(type, index, text) { - if (!tabBar) { - return; - } - if (type === 'none') { - tabBar.hideTabBarRedDot({ - index, - }); - tabBar.removeTabBarBadge({ - index, - }); - } - else if (type === 'text') { - tabBar.setTabBarBadge({ - index, - text, - }); - } - else if (type === 'redDot') { - tabBar.showTabBarRedDot({ - index, - }); - } - } - /** - * 动态设置 tabBar 某一项的内容 - */ - function setTabBarItem(index, text, iconPath, selectedIconPath) { - const item = { - index, - }; - if (text !== undefined) { - item.text = text; - } - if (iconPath) { - item.iconPath = getRealPath(iconPath); - } - if (selectedIconPath) { - item.selectedIconPath = getRealPath(selectedIconPath); - } - tabBar && tabBar.setTabBarItem(item); - } - /** - * 动态设置 tabBar 的整体样式 - * @param {Object} style 样式 - */ - function setTabBarStyle(style) { - tabBar && tabBar.setTabBarStyle(style); - } - /** - * 隐藏 tabBar - * @param {boolean} animation 是否需要动画效果 - */ - function hideTabBar(animation) { - visible = false; - tabBar && - tabBar.hideTabBar({ - animation, - }); - } - /** - * 显示 tabBar - * @param {boolean} animation 是否需要动画效果 - */ - function showTabBar(animation) { - visible = true; - tabBar && - tabBar.showTabBar({ - animation, - }); - } - const maskClickCallback = []; - var tabBarInstance = { - id: '0', - init(options, clickCallback) { - if (options && options.list.length) { - config = options; - } - try { - tabBar = weex.requireModule('uni-tabview'); - } - catch (error) { - console.log(`uni.requireNativePlugin("uni-tabview") error ${error}`); - } - tabBar.onMaskClick(() => { - maskClickCallback.forEach((callback) => { - callback(); - }); - }); - tabBar && - tabBar.onClick(({ index }) => { - clickCallback(config.list[index], index); - }); - tabBar && - tabBar.onMidButtonClick(() => { - // publish('onTabBarMidButtonTap', {}) - }); - }, - indexOf(page) { - const itemLength = config && config.list && config.list.length; - if (itemLength) { - for (let i = 0; i < itemLength; i++) { - if (config.list[i].pagePath === page || - config.list[i].pagePath === `${page}.html`) { - return i; - } - } - } - return -1; - }, - switchTab(page) { - const index = this.indexOf(page); - if (index >= 0) { - tabBar && - tabBar.switchSelect({ - index, - }); - return true; - } - return false; - }, - setTabBarBadge, - setTabBarItem, - setTabBarStyle, - hideTabBar, - showTabBar, - append(webview) { - tabBar && - tabBar.append({ - id: webview.id, - }, ({ code }) => { - if (code !== 0) { - setTimeout(() => { - this.append(webview); - }, 20); - } - }); - }, - get visible() { - return visible; - }, - get height() { - return ((config && config.height ? parseFloat(config.height) : TABBAR_HEIGHT) + - plus.navigator.getSafeAreaInsets().deviceBottom); - }, - // tabBar是否遮挡内容区域 - get cover() { - const array = ['extralight', 'light', 'dark']; - return isIOS && array.indexOf(config.blurEffect) >= 0; - }, - setStyle({ mask }) { - tabBar.setMask({ - color: mask, - }); - }, - addEventListener(_name, callback) { - maskClickCallback.push(callback); - }, - removeEventListener(_name, callback) { - const callbackIndex = maskClickCallback.indexOf(callback); - maskClickCallback.splice(callbackIndex, 1); - }, - }; - - function initTabBar() { - const { tabBar } = __uniConfig; - const len = tabBar && tabBar.list && tabBar.list.length; - if (!len) { - return; - } - const { entryPagePath } = __uniConfig; - tabBar.selectedIndex = 0; - const selected = tabBar.list.findIndex((page) => page.pagePath === entryPagePath); - tabBarInstance.init(tabBar, (item, index) => { - uni.switchTab({ - url: '/' + item.pagePath, - openType: 'switchTab', - from: 'tabBar', - success() { - invokeHook('onTabItemTap', { - index, - text: item.text, - pagePath: item.pagePath, - }); - }, - }); - }); - if (selected !== -1) { - // 取当前 tab 索引值 - tabBar.selectedIndex = selected; - selected !== 0 && tabBarInstance.switchTab(entryPagePath); - } + if (len % 3 === 2) { + base64 = base64.substring(0, base64.length - 1) + '='; + } else if (len % 3 === 1) { + base64 = base64.substring(0, base64.length - 2) + '=='; } - const callbacks = {}; - // 简单处理 view 层与 service 层的通知系统 - /** - * 消费 view 层通知 - */ - function consumePlusMessage(type, args) { - // 处理 web-view 组件发送的通知 - if (type === WEB_INVOKE_APPSERVICE) { - UniServiceJSBridge.emit('onWebInvokeAppService', args.data, args.webviewIds); - return true; - } - const callback = callbacks[type]; - if (callback) { - callback(args); - if (!callback.keepAlive) { - delete callbacks[type]; - } - return true; - } - return false; - } + return base64 + } - function backbuttonListener() { - uni.navigateBack({ - from: 'backbutton', - }); - } + function decode(base64) { + var bufferLength = base64.length * 0.75, + len = base64.length, + i, + p = 0, + encoded1, + encoded2, + encoded3, + encoded4; - function initGlobalEvent() { - const plusGlobalEvent = plus.weexGlobalEvent; - const weexGlobalEvent = weex.requireModule('weexGlobalEvent'); - const emit = UniServiceJSBridge.emit; - if (weex.config.preload) { - plus.key.addEventListener('backbutton', backbuttonListener); - } - else { - plusGlobalEvent.addEventListener('splashclosed', () => { - plus.key.addEventListener('backbutton', backbuttonListener); - }); - } - plusGlobalEvent.addEventListener('pause', () => { - emit('onAppEnterBackground'); - }); - plusGlobalEvent.addEventListener('resume', () => { - emit('onAppEnterForeground'); - }); - weexGlobalEvent.addEventListener('uistylechange', function (event) { - const args = { - theme: event.uistyle, - }; - emit('onThemeChange', args); - }); - plusGlobalEvent.addEventListener('plusMessage', onPlusMessage); - // nvue webview post message - plusGlobalEvent.addEventListener('WebviewPostMessage', onPlusMessage); - } - function onPlusMessage(e) { - if (e.data && e.data.type) { - const type = e.data.type; - consumePlusMessage(type, e.data.args || {}); - } + if (base64[base64.length - 1] === '=') { + bufferLength--; + if (base64[base64.length - 2] === '=') { + bufferLength--; + } } - let appCtx; - const defaultApp = { - globalData: {}, - }; - function registerApp(appVm) { - appCtx = appVm; - appCtx.$vm = appVm; - extend(appCtx, defaultApp); // 拷贝默认实现 - const { $options } = appVm; - if ($options) { - appCtx.globalData = extend($options.globalData || {}, appCtx.globalData); - } - initEntry(); - initTabBar(); - initGlobalEvent(); - } + var arraybuffer = new ArrayBuffer(bufferLength), + bytes = new Uint8Array(arraybuffer); - function initRouteOptions(path, openType) { - // 需要序列化一遍 - const routeOptions = JSON.parse(JSON.stringify(__uniRoutes.find((route) => route.path === path))); - if (openType === 'reLaunch' || - (!__uniConfig.realEntryPagePath && getCurrentPages().length === 0) // redirectTo - ) { - routeOptions.meta.isQuit = true; - } - else if (!routeOptions.meta.isTabBar) { - routeOptions.meta.isQuit = false; - } - // TODO - // if (routeOptions.meta.isTabBar) { - // routeOptions.meta.visible = true - // } - return routeOptions; - } + for (i = 0; i < len; i += 4) { + encoded1 = lookup[base64.charCodeAt(i)]; + encoded2 = lookup[base64.charCodeAt(i + 1)]; + encoded3 = lookup[base64.charCodeAt(i + 2)]; + encoded4 = lookup[base64.charCodeAt(i + 3)]; - function initNVue(webviewStyle, routeMeta, path) { - if (path && routeMeta.isNVue) { - webviewStyle.uniNView = { - path, - defaultFontSize: __uniConfig.defaultFontSize, - viewport: __uniConfig.viewport, - }; - } + bytes[p++] = (encoded1 << 2) | (encoded2 >> 4); + bytes[p++] = ((encoded2 & 15) << 4) | (encoded3 >> 2); + bytes[p++] = ((encoded3 & 3) << 6) | (encoded4 & 63); } - const colorRE = /^#[a-z0-9]{6}$/i; - function isColor(color) { - return color && (colorRE.test(color) || color === 'transparent'); - } + return arraybuffer + } - function initBackgroundColor(webviewStyle, routeMeta) { - const { backgroundColor } = routeMeta; - if (!backgroundColor) { - return; - } - if (!isColor(backgroundColor)) { - return; - } - if (!webviewStyle.background) { - webviewStyle.background = backgroundColor; - } - if (!webviewStyle.backgroundColorTop) { - webviewStyle.backgroundColorTop = backgroundColor; - } - } + /** + * Make a map and return a function for checking if a key + * is in that map. + * IMPORTANT: all calls of this function must be prefixed with + * \/\*#\_\_PURE\_\_\*\/ + * So that rollup can tree-shake them if necessary. + */ + function makeMap(str, expectsLowerCase) { + const map = Object.create(null); + const list = str.split(','); + for (let i = 0; i < list.length; i++) { + map[list[i]] = true; + } + return expectsLowerCase ? val => !!map[val.toLowerCase()] : val => !!map[val]; + } + (process.env.NODE_ENV !== 'production') + ? Object.freeze({}) + : {}; + (process.env.NODE_ENV !== 'production') ? Object.freeze([]) : []; + const extend = Object.assign; + const hasOwnProperty$1 = Object.prototype.hasOwnProperty; + const hasOwn$1 = (val, key) => hasOwnProperty$1.call(val, key); + const isArray = Array.isArray; + const isFunction = (val) => typeof val === 'function'; + const isString = (val) => typeof val === 'string'; + const isObject$1 = (val) => val !== null && typeof val === 'object'; + const objectToString = Object.prototype.toString; + const toTypeString = (value) => objectToString.call(value); + const toRawType = (value) => { + // extract "RawType" from strings like "[object RawType]" + return toTypeString(value).slice(8, -1); + }; + const isPlainObject = (val) => toTypeString(val) === '[object Object]'; + const cacheStringFunction$1 = (fn) => { + const cache = Object.create(null); + return ((str) => { + const hit = cache[str]; + return hit || (cache[str] = fn(str)); + }); + }; + /** + * @private + */ + const capitalize = cacheStringFunction$1((str) => str.charAt(0).toUpperCase() + str.slice(1)); - function initPopGesture(webviewStyle, routeMeta) { - // 不支持 hide - if (webviewStyle.popGesture === 'hide') { - delete webviewStyle.popGesture; - } - // 似乎没用了吧？记得是之前流应用时，需要 appback 的逻辑 - if (routeMeta.isQuit) { - webviewStyle.popGesture = (plus.os.name === 'iOS' ? 'appback' : 'none'); - } - } + const HTTP_METHODS = [ + 'GET', + 'OPTIONS', + 'HEAD', + 'POST', + 'PUT', + 'DELETE', + 'TRACE', + 'CONNECT', + ]; + function elemInArray(str, arr) { + if (!str || arr.indexOf(str) === -1) { + return arr[0]; + } + return str; + } + function validateProtocolFail(name, msg) { + console.warn(`${name}: ${msg}`); + } + function validateProtocol(name, data, protocol, onFail) { + if (!onFail) { + onFail = validateProtocolFail; + } + for (const key in protocol) { + const errMsg = validateProp(key, data[key], protocol[key], !hasOwn$1(data, key)); + if (isString(errMsg)) { + onFail(name, errMsg); + } + } + } + function validateProtocols(name, args, protocol, onFail) { + if (!protocol) { + return; + } + if (!isArray(protocol)) { + return validateProtocol(name, args[0] || Object.create(null), protocol, onFail); + } + const len = protocol.length; + const argsLen = args.length; + for (let i = 0; i < len; i++) { + const opts = protocol[i]; + const data = Object.create(null); + if (argsLen > i) { + data[opts.name] = args[i]; + } + validateProtocol(name, data, { [opts.name]: opts }, onFail); + } + } + function validateProp(name, value, prop, isAbsent) { + if (!isPlainObject(prop)) { + prop = { type: prop }; + } + const { type, required, validator } = prop; + // required! + if (required && isAbsent) { + return 'Missing required args: "' + name + '"'; + } + // missing but optional + if (value == null && !required) { + return; + } + // type check + if (type != null) { + let isValid = false; + const types = isArray(type) ? type : [type]; + const expectedTypes = []; + // value is valid as long as one of the specified types match + for (let i = 0; i < types.length && !isValid; i++) { + const { valid, expectedType } = assertType(value, types[i]); + expectedTypes.push(expectedType || ''); + isValid = valid; + } + if (!isValid) { + return getInvalidTypeMessage(name, value, expectedTypes); + } + } + // custom validator + if (validator) { + return validator(value); + } + } + const isSimpleType = /*#__PURE__*/ makeMap('String,Number,Boolean,Function,Symbol'); + function assertType(value, type) { + let valid; + const expectedType = getType(type); + if (isSimpleType(expectedType)) { + const t = typeof value; + valid = t === expectedType.toLowerCase(); + // for primitive wrapper objects + if (!valid && t === 'object') { + valid = value instanceof type; + } + } + else if (expectedType === 'Object') { + valid = isObject$1(value); + } + else if (expectedType === 'Array') { + valid = isArray(value); + } + else { + { + valid = value instanceof type; + } + } + return { + valid, + expectedType, + }; + } + function getInvalidTypeMessage(name, value, expectedTypes) { + let message = `Invalid args: type check failed for args "${name}".` + + ` Expected ${expectedTypes.map(capitalize).join(', ')}`; + const expectedType = expectedTypes[0]; + const receivedType = toRawType(value); + const expectedValue = styleValue(value, expectedType); + const receivedValue = styleValue(value, receivedType); + // check if we need to specify expected value + if (expectedTypes.length === 1 && + isExplicable(expectedType) && + !isBoolean(expectedType, receivedType)) { + message += ` with value ${expectedValue}`; + } + message += `, got ${receivedType} `; + // check if we need to specify received value + if (isExplicable(receivedType)) { + message += `with value ${receivedValue}.`; + } + return message; + } + function getType(ctor) { + const match = ctor && ctor.toString().match(/^\s*function (\w+)/); + return match ? match[1] : ''; + } + function styleValue(value, type) { + if (type === 'String') { + return `"${value}"`; + } + else if (type === 'Number') { + return `${Number(value)}`; + } + else { + return `${value}`; + } + } + function isExplicable(type) { + const explicitTypes = ['string', 'number', 'boolean']; + return explicitTypes.some((elem) => type.toLowerCase() === elem); + } + function isBoolean(...args) { + return args.some((elem) => elem.toLowerCase() === 'boolean'); + } - function initPullToRefresh(webviewStyle, routeMeta) { - if (!routeMeta.enablePullDownRefresh) { - return; - } - webviewStyle.pullToRefresh = normalizePullToRefreshRpx(extend({}, plus.os.name === 'Android' - ? defaultAndroidPullToRefresh - : defaultPullToRefresh, routeMeta.pullToRefresh)); - } - const defaultAndroidPullToRefresh = { support: true, style: 'circle' }; - const defaultPullToRefresh = { - support: true, - style: 'default', - height: '50px', - range: '200px', - contentdown: { - caption: '', - }, - contentover: { - caption: '', - }, - contentrefresh: { - caption: '', - }, - }; - - function initTitleNView(webviewStyle, routeMeta) { - const { navigationBar } = routeMeta; - if (navigationBar.style === 'custom') { - return false; - } - let autoBackButton = true; - if (routeMeta.isQuit) { - autoBackButton = false; - } - const titleNView = { - autoBackButton, - }; - Object.keys(navigationBar).forEach((name) => { - const value = navigationBar[name]; - if (name === 'backgroundColor') { - titleNView.backgroundColor = isColor(value) - ? value - : BACKGROUND_COLOR; - } - else if (name === 'titleImage' && value) { - titleNView.tags = createTitleImageTags(value); - } - else if (name === 'buttons' && isArray(value)) { - titleNView.buttons = value.map((button, index) => { - button.onclick = createTitleNViewBtnClick(index); - return button; - }); - } - }); - webviewStyle.titleNView = titleNView; - } - function createTitleImageTags(titleImage) { - return [ - { - tag: 'img', - src: titleImage, - position: { - left: 'auto', - top: 'auto', - width: 'auto', - height: '26px', - }, - }, - ]; - } - function createTitleNViewBtnClick(index) { - return function onClick(btn) { - btn.index = index; - invokeHook('onNavigationBarButtonTap', btn); - }; - } + function tryCatch(fn) { + return function () { + try { + return fn.apply(fn, arguments); + } + catch (e) { + // TODO + console.error(e); + } + }; + } - function parseWebviewStyle(id, path, routeOptions) { - const webviewStyle = { - bounce: 'vertical', - }; - const routeMeta = mergePageMeta(id, routeOptions.meta); - Object.keys(routeMeta).forEach((name) => { - if (WEBVIEW_STYLE_BLACKLIST.indexOf(name) === -1) { - webviewStyle[name] = - routeMeta[name]; - } - }); - initNVue(webviewStyle, routeMeta, path); - initPopGesture(webviewStyle, routeMeta); - initBackgroundColor(webviewStyle, routeMeta); - initTitleNView(webviewStyle, routeMeta); - initPullToRefresh(webviewStyle, routeMeta); - return webviewStyle; - } - const WEBVIEW_STYLE_BLACKLIST = [ - 'id', - 'route', - 'isNVue', - 'isQuit', - 'isEntry', - 'isTabBar', - 'tabBarIndex', - 'windowTop', - 'topWindow', - 'leftWindow', - 'rightWindow', - 'maxWidth', - 'usingComponents', - 'disableScroll', - 'enablePullDownRefresh', - 'navigationBar', - 'pullToRefresh', - 'onReachBottomDistance', - 'pageOrientation', - 'backgroundColor', - ]; - - let id = 2; - let preloadWebview; - function getWebviewId() { - return id; - } - function genWebviewId() { - return id++; - } - function getPreloadWebview() { - return preloadWebview; - } - function encode(val) { - return val; - } - function initUniPageUrl(path, query) { - const queryString = query ? stringifyQuery(query, encode) : ''; - return { - path: path.substr(1), - query: queryString ? queryString.substr(1) : queryString, - }; - } + let invokeCallbackId = 1; + const invokeCallbacks = {}; + function addInvokeCallback(id, name, callback, keepAlive = false) { + invokeCallbacks[id] = { + name, + keepAlive, + callback, + }; + return id; + } + // onNativeEventReceive((event,data)=>{}) 需要两个参数，目前写死最多两个参数 + function invokeCallback(id, res, extras) { + if (typeof id === 'number') { + const opts = invokeCallbacks[id]; + if (opts) { + if (!opts.keepAlive) { + delete invokeCallbacks[id]; + } + return opts.callback(res, extras); + } + } + return res; + } + function findInvokeCallbackByName(name) { + for (const key in invokeCallbacks) { + if (invokeCallbacks[key].name === name) { + return true; + } + } + return false; + } + function onKeepAliveApiCallback(name) { + UniServiceJSBridge.on('api.' + name, (res) => { + for (const key in invokeCallbacks) { + const opts = invokeCallbacks[key]; + if (opts.name === name) { + opts.callback(res); + } + } + }); + } + function createKeepAliveApiCallback(name, callback) { + return addInvokeCallback(invokeCallbackId++, name, callback, true); + } + const API_SUCCESS = 'success'; + const API_FAIL = 'fail'; + const API_COMPLETE = 'complete'; + function getApiCallbacks(args) { + const apiCallbacks = {}; + for (const name in args) { + const fn = args[name]; + if (isFunction(fn)) { + apiCallbacks[name] = tryCatch(fn); + delete args[name]; + } + } + return apiCallbacks; + } + function normalizeErrMsg(errMsg, name) { + if (!errMsg || errMsg.indexOf(':fail') === -1) { + return name + ':ok'; + } + return name + errMsg.substring(errMsg.indexOf(':fail')); + } + function createAsyncApiCallback(name, args = {}, { beforeAll, beforeSuccess } = {}) { + if (!isPlainObject(args)) { + args = {}; + } + const { success, fail, complete } = getApiCallbacks(args); + const hasSuccess = isFunction(success); + const hasFail = isFunction(fail); + const hasComplete = isFunction(complete); + const callbackId = invokeCallbackId++; + addInvokeCallback(callbackId, name, (res) => { + res = res || {}; + res.errMsg = normalizeErrMsg(res.errMsg, name); + isFunction(beforeAll) && beforeAll(res); + if (res.errMsg === name + ':ok') { + isFunction(beforeSuccess) && beforeSuccess(res); + hasSuccess && success(res); + } + else { + hasFail && fail(res); + } + hasComplete && complete(res); + }); + return callbackId; + } - function createNVueWebview({ path, query, routeOptions, webviewStyle, }) { - const curWebviewId = genWebviewId(); - const curWebviewStyle = parseWebviewStyle(curWebviewId, path, routeOptions); - curWebviewStyle.uniPageUrl = initUniPageUrl(path, query); - if ((process.env.NODE_ENV !== 'production')) { - console.log('[uni-app] createWebview', curWebviewId, path, curWebviewStyle); - } - curWebviewStyle.isTab = !!routeOptions.meta.isTabBar; - return plus.webview.create('', String(curWebviewId), curWebviewStyle, extend({ - nvue: true, - }, webviewStyle)); - } + const callbacks$3 = [API_SUCCESS, API_FAIL, API_COMPLETE]; + function hasCallback(args) { + if (isPlainObject(args) && + callbacks$3.find((cb) => isFunction(args[cb]))) { + return true; + } + return false; + } + function handlePromise(promise) { + if (__UNI_FEATURE_PROMISE__) { + return promise + .then((data) => { + return [null, data]; + }) + .catch((err) => [err]); + } + return promise; + } + function promisify(fn) { + return (args = {}) => { + if (hasCallback(args)) { + return fn(args); + } + return handlePromise(new Promise((resolve, reject) => { + fn(extend(args, { success: resolve, fail: reject })); + })); + }; + } - function createWebview(options) { - if (options.routeOptions.meta.isNVue) { - return createNVueWebview(options); - } - if (getWebviewId() === 2) { - // 如果首页非 nvue，则直接返回 Launch Webview - return plus.webview.getLaunchWebview(); - } - return getPreloadWebview(); - } + function formatApiArgs(args, options) { + const params = args[0]; + if (!options || + (!isPlainObject(options.formatArgs) && isPlainObject(params))) { + return; + } + const formatArgs = options.formatArgs; + const keys = Object.keys(formatArgs); + for (let i = 0; i < keys.length; i++) { + const name = keys[i]; + const formatterOrDefaultValue = formatArgs[name]; + if (isFunction(formatterOrDefaultValue)) { + const errMsg = formatterOrDefaultValue(args[0][name], params); + if (isString(errMsg)) { + return errMsg; + } + } + else { + // defaultValue + if (!hasOwn$1(params, name)) { + params[name] = formatterOrDefaultValue; + } + } + } + } + function invokeSuccess(id, name, res) { + return invokeCallback(id, extend(res || {}, { errMsg: name + ':ok' })); + } + function invokeFail(id, name, errMsg, errRes) { + return invokeCallback(id, extend({ errMsg: name + ':fail' + (errMsg ? ' ' + errMsg : '') }, errRes)); + } + function beforeInvokeApi(name, args, protocol, options) { + if ((process.env.NODE_ENV !== 'production')) { + validateProtocols(name, args, protocol); + } + if (options && options.beforeInvoke) { + const errMsg = options.beforeInvoke(args); + if (isString(errMsg)) { + return errMsg; + } + } + const errMsg = formatApiArgs(args, options); + if (errMsg) { + return errMsg; + } + } + function checkCallback(callback) { + if (!isFunction(callback)) { + throw new Error('Invalid args: type check failed for args "callback". Expected Function'); + } + } + function wrapperOnApi(name, fn, options) { + return (callback) => { + checkCallback(callback); + const errMsg = beforeInvokeApi(name, [callback], undefined, options); + if (errMsg) { + throw new Error(errMsg); + } + // 是否是首次调用on,如果是首次，需要初始化onMethod监听 + const isFirstInvokeOnApi = !findInvokeCallbackByName(name); + createKeepAliveApiCallback(name, callback); + if (isFirstInvokeOnApi) { + onKeepAliveApiCallback(name); + fn(); + } + }; + } + function wrapperTaskApi(name, fn, protocol, options) { + return (args) => { + const id = createAsyncApiCallback(name, args, options); + const errMsg = beforeInvokeApi(name, [args], protocol, options); + if (errMsg) { + return invokeFail(id, name, errMsg); + } + return fn(args, { + resolve: (res) => invokeSuccess(id, name, res), + reject: (errMsg, errRes) => invokeFail(id, name, errMsg, errRes), + }); + }; + } + function wrapperSyncApi(name, fn, protocol, options) { + return (...args) => { + const errMsg = beforeInvokeApi(name, args, protocol, options); + if (errMsg) { + throw new Error(errMsg); + } + return fn.apply(null, args); + }; + } + function wrapperAsyncApi(name, fn, protocol, options) { + return wrapperTaskApi(name, fn, protocol, options); + } + function defineOnApi(name, fn, options) { + return wrapperOnApi(name, fn, options); + } + function defineTaskApi(name, fn, protocol, options) { + return promisify(wrapperTaskApi(name, fn, (process.env.NODE_ENV !== 'production') ? protocol : undefined, options)); + } + function defineSyncApi(name, fn, protocol, options) { + return wrapperSyncApi(name, fn, (process.env.NODE_ENV !== 'production') ? protocol : undefined, options); + } + function defineAsyncApi(name, fn, protocol, options) { + return promisify(wrapperAsyncApi(name, fn, (process.env.NODE_ENV !== 'production') ? protocol : undefined, options)); + } - function registerPage({ path, query, openType, webview, }) { - // fast 模式，nvue 首页时，会在nvue中主动调用registerPage并传入首页webview，此时初始化一下首页（因为此时可能还未调用registerApp） - if (webview) { - initEntry(); - } - // TODO preloadWebview - const routeOptions = initRouteOptions(path, openType); - if (!webview) { - webview = createWebview({ path, routeOptions, query }); - } - else { - webview = plus.webview.getWebviewById(webview.id); - webview.nvue = routeOptions.meta.isNVue; - } - if ((process.env.NODE_ENV !== 'production')) { - console.log(`[uni-app] registerPage(${path},${webview.id})`); - } - } + const API_BASE64_TO_ARRAY_BUFFER = 'base64ToArrayBuffer'; + const Base64ToArrayBufferProtocol = [ + { + name: 'base64', + type: String, + required: true, + }, + ]; + const API_ARRAY_BUFFER_TO_BASE64 = 'arrayBufferToBase64'; + const ArrayBufferToBase64Protocol = [ + { + name: 'arrayBuffer', + type: [ArrayBuffer, Uint8Array], + required: true, + }, + ]; + + // @ts-ignore + const base64ToArrayBuffer = defineSyncApi(API_BASE64_TO_ARRAY_BUFFER, (base64) => { + return decode(base64); + }, Base64ToArrayBufferProtocol); + const arrayBufferToBase64 = defineSyncApi(API_ARRAY_BUFFER_TO_BASE64, (arrayBuffer) => { + return encode$3(arrayBuffer); + }, ArrayBufferToBase64Protocol); + + const cacheStringFunction = (fn) => { + const cache = Object.create(null); + return ((str) => { + const hit = cache[str]; + return hit || (cache[str] = fn(str)); + }); + }; + const invokeArrayFns = (fns, arg) => { + let ret; + for (let i = 0; i < fns.length; i++) { + ret = fns[i](arg); + } + return ret; + }; + function once(fn, ctx = null) { + let res; + return ((...args) => { + if (fn) { + res = fn.apply(ctx, args); + fn = null; + } + return res; + }); + } + function callOptions(options, data) { + options = options || {}; + if (typeof data === 'string') { + data = { + errMsg: data, + }; + } + if (/:ok$/.test(data.errMsg)) { + if (typeof options.success === 'function') { + options.success(data); + } + } + else { + if (typeof options.fail === 'function') { + options.fail(data); + } + } + if (typeof options.complete === 'function') { + options.complete(data); + } + } + + const encode$2 = encodeURIComponent; + function stringifyQuery$1(obj, encodeStr = encode$2) { + const res = obj + ? Object.keys(obj) + .map((key) => { + let val = obj[key]; + if (typeof val === undefined || val === null) { + val = ''; + } + else if (isPlainObject(val)) { + val = JSON.stringify(val); + } + return encodeStr(key) + '=' + encodeStr(val); + }) + .filter((x) => x.length > 0) + .join('&') + : null; + return res ? `?${res}` : ''; + } + const TABBAR_HEIGHT = 50; + const PRIMARY_COLOR = '#007aff'; + const BACKGROUND_COLOR = '#f7f7f7'; // 背景色，如标题栏默认背景色 + const SCHEME_RE = /^([a-z-]+:)?\/\//i; + const DATA_RE = /^data:.*,.*/; + const WEB_INVOKE_APPSERVICE = 'WEB_INVOKE_APPSERVICE'; + + const isObject = (val) => val !== null && typeof val === 'object'; + class BaseFormatter { + constructor() { + this._caches = Object.create(null); + } + interpolate(message, values) { + if (!values) { + return [message]; + } + let tokens = this._caches[message]; + if (!tokens) { + tokens = parse(message); + this._caches[message] = tokens; + } + return compile(tokens, values); + } + } + const RE_TOKEN_LIST_VALUE = /^(?:\d)+/; + const RE_TOKEN_NAMED_VALUE = /^(?:\w)+/; + function parse(format) { + const tokens = []; + let position = 0; + let text = ''; + while (position < format.length) { + let char = format[position++]; + if (char === '{') { + if (text) { + tokens.push({ type: 'text', value: text }); + } + text = ''; + let sub = ''; + char = format[position++]; + while (char !== undefined && char !== '}') { + sub += char; + char = format[position++]; + } + const isClosed = char === '}'; + const type = RE_TOKEN_LIST_VALUE.test(sub) + ? 'list' + : isClosed && RE_TOKEN_NAMED_VALUE.test(sub) + ? 'named' + : 'unknown'; + tokens.push({ value: sub, type }); + } + else if (char === '%') { + // when found rails i18n syntax, skip text capture + if (format[position] !== '{') { + text += char; + } + } + else { + text += char; + } + } + text && tokens.push({ type: 'text', value: text }); + return tokens; + } + function compile(tokens, values) { + const compiled = []; + let index = 0; + const mode = Array.isArray(values) + ? 'list' + : isObject(values) + ? 'named' + : 'unknown'; + if (mode === 'unknown') { + return compiled; + } + while (index < tokens.length) { + const token = tokens[index]; + switch (token.type) { + case 'text': + compiled.push(token.value); + break; + case 'list': + compiled.push(values[parseInt(token.value, 10)]); + break; + case 'named': + if (mode === 'named') { + compiled.push(values[token.value]); + } + else { + if (process.env.NODE_ENV !== 'production') { + console.warn(`Type of token '${token.type}' and format of value '${mode}' don't match!`); + } + } + break; + case 'unknown': + if (process.env.NODE_ENV !== 'production') { + console.warn(`Detect 'unknown' type of token!`); + } + break; + } + index++; + } + return compiled; + } + + const LOCALE_ZH_HANS = 'zh-Hans'; + const LOCALE_ZH_HANT = 'zh-Hant'; + const LOCALE_EN = 'en'; + const LOCALE_FR = 'fr'; + const LOCALE_ES = 'es'; + const hasOwnProperty = Object.prototype.hasOwnProperty; + const hasOwn = (val, key) => hasOwnProperty.call(val, key); + const defaultFormatter = new BaseFormatter(); + function include(str, parts) { + return !!parts.find((part) => str.indexOf(part) !== -1); + } + function startsWith(str, parts) { + return parts.find((part) => str.indexOf(part) === 0); + } + function normalizeLocale(locale, messages) { + if (!locale) { + return; + } + locale = locale.trim().replace(/_/g, '-'); + if (messages[locale]) { + return locale; + } + locale = locale.toLowerCase(); + if (locale.indexOf('zh') === 0) { + if (locale.indexOf('-hans') !== -1) { + return LOCALE_ZH_HANS; + } + if (locale.indexOf('-hant') !== -1) { + return LOCALE_ZH_HANT; + } + if (include(locale, ['-tw', '-hk', '-mo', '-cht'])) { + return LOCALE_ZH_HANT; + } + return LOCALE_ZH_HANS; + } + const lang = startsWith(locale, [LOCALE_EN, LOCALE_FR, LOCALE_ES]); + if (lang) { + return lang; + } + } + class I18n { + constructor({ locale, fallbackLocale, messages, watcher, formater, }) { + this.locale = LOCALE_EN; + this.fallbackLocale = LOCALE_EN; + this.message = {}; + this.messages = {}; + this.watchers = []; + if (fallbackLocale) { + this.fallbackLocale = fallbackLocale; + } + this.formater = formater || defaultFormatter; + this.messages = messages || {}; + this.setLocale(locale); + if (watcher) { + this.watchLocale(watcher); + } + } + setLocale(locale) { + const oldLocale = this.locale; + this.locale = normalizeLocale(locale, this.messages) || this.fallbackLocale; + if (!this.messages[this.locale]) { + // 可能初始化时不存在 + this.messages[this.locale] = {}; + } + this.message = this.messages[this.locale]; + this.watchers.forEach((watcher) => { + watcher(this.locale, oldLocale); + }); + } + getLocale() { + return this.locale; + } + watchLocale(fn) { + const index = this.watchers.push(fn) - 1; + return () => { + this.watchers.splice(index, 1); + }; + } + add(locale, message) { + if (this.messages[locale]) { + Object.assign(this.messages[locale], message); + } + else { + this.messages[locale] = message; + } + } + t(key, locale, values) { + let message = this.message; + if (typeof locale === 'string') { + locale = normalizeLocale(locale, this.messages); + locale && (message = this.messages[locale]); + } + else { + values = locale; + } + if (!hasOwn(message, key)) { + console.warn(`Cannot translate the value of keypath ${key}. Use the value of keypath as default.`); + return key; + } + return this.formater.interpolate(message[key], values).join(''); + } + } + + function initLocaleWatcher(appVm, i18n) { + appVm.$i18n && + appVm.$i18n.vm.$watch('locale', (newLocale) => { + i18n.setLocale(newLocale); + }, { + immediate: true, + }); + } + // function getDefaultLocale() { + // if (typeof navigator !== 'undefined') { + // return (navigator as any).userLanguage || navigator.language + // } + // if (typeof plus !== 'undefined') { + // // TODO 待调整为最新的获取语言代码 + // return plus.os.language + // } + // return uni.getSystemInfoSync().language + // } + function initVueI18n(locale = LOCALE_EN, messages = {}, fallbackLocale = LOCALE_EN) { + // 兼容旧版本入参 + if (typeof locale !== 'string') { + [locale, messages] = [messages, locale]; + } + if (typeof locale !== 'string') { + locale = fallbackLocale; + } + const i18n = new I18n({ + locale: locale || fallbackLocale, + fallbackLocale, + messages, + }); + let t = (key, values) => { + if (typeof getApp !== 'function') { + // app view + /* eslint-disable no-func-assign */ + t = function (key, values) { + return i18n.t(key, values); + }; + } + else { + const appVm = getApp().$vm; + if (!appVm.$t || !appVm.$i18n) { + // if (!locale) { + // i18n.setLocale(getDefaultLocale()) + // } + /* eslint-disable no-func-assign */ + t = function (key, values) { + return i18n.t(key, values); + }; + } + else { + initLocaleWatcher(appVm, i18n); + /* eslint-disable no-func-assign */ + t = function (key, values) { + const $i18n = appVm.$i18n; + const silentTranslationWarn = $i18n.silentTranslationWarn; + $i18n.silentTranslationWarn = true; + const msg = appVm.$t(key, values); + $i18n.silentTranslationWarn = silentTranslationWarn; + if (msg !== key) { + return msg; + } + return i18n.t(key, $i18n.locale, values); + }; + } + } + return t(key, values); + }; + return { + i18n, + t(key, values) { + return t(key, values); + }, + add(locale, message) { + return i18n.add(locale, message); + }, + getLocale() { + return i18n.getLocale(); + }, + setLocale(newLocale) { + return i18n.setLocale(newLocale); + }, + }; + } + + let i18n; + function useI18n() { + if (!i18n) { + let language; + { + { + language = navigator.language; + } + } + i18n = initVueI18n(language); + } + return i18n; + } + + // This file is created by scripts/i18n.js + function normalizeMessages(namespace, messages) { + return Object.keys(messages).reduce((res, name) => { + res[namespace + name] = messages[name]; + return res; + }, {}); + } + const initI18nShowActionSheetMsgsOnce = /*#__PURE__*/ once(() => { + const name = 'uni.showActionSheet.'; + if (__UNI_FEATURE_I18N_EN__) { + useI18n().add(LOCALE_EN, normalizeMessages(name, { cancel: 'Cancel' })); + } + if (__UNI_FEATURE_I18N_ES__) { + useI18n().add(LOCALE_ES, normalizeMessages(name, { cancel: 'Cancelar' })); + } + if (__UNI_FEATURE_I18N_FR__) { + useI18n().add(LOCALE_FR, normalizeMessages(name, { cancel: 'Annuler' })); + } + if (__UNI_FEATURE_I18N_ZH_HANS__) { + useI18n().add(LOCALE_ZH_HANS, normalizeMessages(name, { cancel: '取消' })); + } + if (__UNI_FEATURE_I18N_ZH_HANT__) { + useI18n().add(LOCALE_ZH_HANT, normalizeMessages(name, { cancel: '取消' })); + } + }); + const initI18nShowModalMsgsOnce = /*#__PURE__*/ once(() => { + const name = 'uni.showModal.'; + if (__UNI_FEATURE_I18N_EN__) { + useI18n().add(LOCALE_EN, normalizeMessages(name, { cancel: 'Cancel', confirm: 'OK' })); + } + if (__UNI_FEATURE_I18N_ES__) { + useI18n().add(LOCALE_ES, normalizeMessages(name, { cancel: 'Cancelar', confirm: 'OK' })); + } + if (__UNI_FEATURE_I18N_FR__) { + useI18n().add(LOCALE_FR, normalizeMessages(name, { cancel: 'Annuler', confirm: 'OK' })); + } + if (__UNI_FEATURE_I18N_ZH_HANS__) { + useI18n().add(LOCALE_ZH_HANS, normalizeMessages(name, { cancel: '取消', confirm: '确定' })); + } + if (__UNI_FEATURE_I18N_ZH_HANT__) { + useI18n().add(LOCALE_ZH_HANT, normalizeMessages(name, { cancel: '取消', confirm: '確定' })); + } + }); + const initI18nChooseImageMsgsOnce = /*#__PURE__*/ once(() => { + const name = 'uni.chooseImage.'; + if (__UNI_FEATURE_I18N_EN__) { + useI18n().add(LOCALE_EN, normalizeMessages(name, { + cancel: 'Cancel', + 'sourceType.album': 'Album', + 'sourceType.camera': 'Camera', + })); + } + if (__UNI_FEATURE_I18N_ES__) { + useI18n().add(LOCALE_ES, normalizeMessages(name, { + cancel: 'Cancelar', + 'sourceType.album': 'Álbum', + 'sourceType.camera': 'Cámara', + })); + } + if (__UNI_FEATURE_I18N_FR__) { + useI18n().add(LOCALE_FR, normalizeMessages(name, { + cancel: 'Annuler', + 'sourceType.album': 'Album', + 'sourceType.camera': 'Caméra', + })); + } + if (__UNI_FEATURE_I18N_ZH_HANS__) { + useI18n().add(LOCALE_ZH_HANS, normalizeMessages(name, { + cancel: '取消', + 'sourceType.album': '从相册选择', + 'sourceType.camera': '拍摄', + })); + } + if (__UNI_FEATURE_I18N_ZH_HANT__) { + useI18n().add(LOCALE_ZH_HANT, normalizeMessages(name, { + cancel: '取消', + 'sourceType.album': '從相冊選擇', + 'sourceType.camera': '拍攝', + })); + } + }); + + function hasRpx(str) { + return str.indexOf('rpx') !== -1 || str.indexOf('upx') !== -1; + } + function rpx2px(str, replace = false) { + if (replace) { + return rpx2pxWithReplace(str); + } + if (typeof str === 'string') { + const res = parseInt(str) || 0; + if (hasRpx(str)) { + return uni.upx2px(res); + } + return res; + } + return str; + } + function rpx2pxWithReplace(str) { + if (!hasRpx(str)) { + return str; + } + return str.replace(/(\d+(\.\d+)?)[ru]px/g, (_a, b) => { + return uni.upx2px(parseFloat(b)) + 'px'; + }); + } + + const PAGE_META_KEYS = ['navigationBar', 'pullToRefresh']; + function initGlobalStyle() { + return JSON.parse(JSON.stringify(__uniConfig.globalStyle || {})); + } + function mergePageMeta(id, pageMeta) { + const globalStyle = initGlobalStyle(); + const res = extend({ id }, globalStyle, pageMeta); + PAGE_META_KEYS.forEach((name) => { + res[name] = extend({}, globalStyle[name], pageMeta[name]); + }); + return res; + } + function normalizePullToRefreshRpx(pullToRefresh) { + if (pullToRefresh.offset) { + pullToRefresh.offset = rpx2px(pullToRefresh.offset); + } + if (pullToRefresh.height) { + pullToRefresh.height = rpx2px(pullToRefresh.height); + } + if (pullToRefresh.range) { + pullToRefresh.range = rpx2px(pullToRefresh.range); + } + return pullToRefresh; + } + + function getRealRoute(fromRoute, toRoute) { + if (toRoute.indexOf('/') === 0) { + return toRoute; + } + if (toRoute.indexOf('./') === 0) { + return getRealRoute(fromRoute, toRoute.substr(2)); + } + const toRouteArray = toRoute.split('/'); + const toRouteLength = toRouteArray.length; + let i = 0; + for (; i < toRouteLength && toRouteArray[i] === '..'; i++) { + // noop + } + toRouteArray.splice(0, i); + toRoute = toRouteArray.join('/'); + const fromRouteArray = fromRoute.length > 0 ? fromRoute.split('/') : []; + fromRouteArray.splice(fromRouteArray.length - i - 1, i + 1); + return '/' + fromRouteArray.concat(toRouteArray).join('/'); + } + + function getCurrentPage() { + const pages = getCurrentPages(); + const len = pages.length; + if (len) { + return pages[len - 1]; + } + } + function getCurrentPageVm() { + const page = getCurrentPage(); + if (page) { + return page.$vm; + } + } + function invokeHook(vm, name, args) { + if (isString(vm)) { + args = name; + name = vm; + vm = getCurrentPageVm(); + } + else if (typeof vm === 'number') { + const page = getCurrentPages().find((page) => page.$page.id === vm); + if (page) { + vm = page.$vm; + } + else { + vm = getCurrentPageVm(); + } + } + if (!vm) { + return; + } + const hooks = vm.$[name]; + return hooks && invokeArrayFns(hooks, args); + } + + function getRealPath(filepath) { + // 无协议的情况补全 https + if (filepath.indexOf('//') === 0) { + return 'https:' + filepath; + } + // 网络资源或base64 + if (SCHEME_RE.test(filepath) || DATA_RE.test(filepath)) { + return filepath; + } + if (isSystemURL(filepath)) { + return 'file://' + normalizeLocalPath(filepath); + } + const wwwPath = 'file://' + normalizeLocalPath('_www'); + // 绝对路径转换为本地文件系统路径 + if (filepath.indexOf('/') === 0) { + // 平台绝对路径 安卓、iOS + if (filepath.startsWith('/storage/') || + filepath.includes('/Containers/Data/Application/')) { + return 'file://' + filepath; + } + return wwwPath + filepath; + } + // 相对资源 + if (filepath.indexOf('../') === 0 || filepath.indexOf('./') === 0) { + // @ts-expect-error app-view + if (typeof __id__ === 'string') { + // @ts-expect-error app-view + return wwwPath + getRealRoute('/' + __id__, filepath); + } + else { + const pages = getCurrentPages(); + if (pages.length) { + return (wwwPath + getRealRoute('/' + pages[pages.length - 1].route, filepath)); + } + } + } + return filepath; + } + const normalizeLocalPath = cacheStringFunction((filepath) => { + return plus.io + .convertLocalFileSystemURL(filepath) + .replace(/^\/?apps\//, '/android_asset/apps/') + .replace(/\/$/, ''); + }); + function isSystemURL(filepath) { + if (filepath.indexOf('_www') === 0 || + filepath.indexOf('_doc') === 0 || + filepath.indexOf('_documents') === 0 || + filepath.indexOf('_downloads') === 0) { + return true; + } + return false; + } + + const API_CREATE_INNER_AUDIO_CONTEXT = 'createInnerAudioContext'; + + //#endregion + /** + * 可以批量设置的监听事件 + */ + const innerAudioContextEventNames = [ + 'onCanplay', + 'onPlay', + 'onPause', + 'onStop', + 'onEnded', + 'onTimeUpdate', + 'onError', + 'onWaiting', + 'onSeeking', + 'onSeeked', + ]; + const innerAudioContextOffEventNames = [ + 'offCanplay', + 'offPlay', + 'offPause', + 'offStop', + 'offEnded', + 'offTimeUpdate', + 'offError', + 'offWaiting', + 'offSeeking', + 'offSeeked', + ]; + + const API_GET_BACKGROUND_AUDIO_MANAGER = 'getBackgroundAudioManager'; + + const API_MAKE_PHONE_CALL = 'makePhoneCall'; + const MakePhoneCallProtocol = { + phoneNumber: String, + }; + + const API_ON_ACCELEROMETER = 'onAccelerometer'; + const API_OFF_ACCELEROMETER = 'offAccelerometer'; + const API_START_ACCELEROMETER = 'startAccelerometer'; + const API_STOP_ACCELEROMETER = 'stopAccelerometer'; + + const API_ON_COMPASS = 'onCompass'; + const API_OFF_COMPASS = 'offCompass'; + const API_START_COMPASS = 'startCompass'; + const API_STOP_COMPASS = 'stopCompass'; + + const API_VIBRATE_SHORT = 'vibrateShort'; + const API_VIBRATE_LONG = 'vibrateLong'; + + const API_ON_BLUETOOTH_DEVICE_FOUND = 'onBluetoothDeviceFound'; + const API_ON_BLUETOOTH_ADAPTER_STATE_CHANGE = 'onBluetoothAdapterStateChange'; + const API_ON_BLE_CONNECTION_STATE_CHANGE = 'onBLEConnectionStateChange'; + const API_ON_BLE_CHARACTERISTIC_VALUE_CHANGE = 'onBLECharacteristicValueChange'; + const API_START_BLUETOOTH_DEVICES_DISCOVERY = 'startBluetoothDevicesDiscovery'; + const StartBluetoothDevicesDiscoveryProtocol = { + services: Array, + allowDuplicatesKey: Boolean, + interval: Number, + }; + const API_GET_CONNECTED_BLUETOOTH_DEVICES = 'getConnectedBluetoothDevices'; + const GetConnectedBluetoothDevicesProtocol = { + services: { + type: Array, + required: true, + }, + }; + const API_CREATE_BLE_CONNECTION = 'createBLEConnection'; + const CreateBLEConnectionProtocol = { + deviceId: { + type: String, + required: true, + }, + }; + const API_CLOSE_BLE_CONNECTION = 'closeBLEConnection'; + const CloseBLEConnectionProtocol = { + deviceId: { + type: String, + required: true, + }, + }; + const API_GET_BLE_DEVICE_SERVICES = 'getBLEDeviceServices'; + const GetBLEDeviceServicesProtocol = { + deviceId: { + type: String, + required: true, + }, + }; + const API_GET_BLE_DEVICE_CHARACTERISTICS = 'getBLEDeviceCharacteristics'; + const GetBLEDeviceCharacteristicsProtocol = { + deviceId: { + type: String, + required: true, + }, + serviceId: { + type: String, + required: true, + }, + }; + const API_NOTIFY_BLE_CHARACTERISTIC_VALUE_CHANGE = 'notifyBLECharacteristicValueChange'; + const NotifyBLECharacteristicValueChangeProtocol = { + deviceId: { + type: String, + required: true, + }, + serviceId: { + type: String, + required: true, + }, + characteristicId: { + type: String, + required: true, + }, + state: { + type: Boolean, + required: true, + }, + }; + const API_READ_BLE_CHARACTERISTIC_VALUE = 'readBLECharacteristicValue'; + const ReadBLECharacteristicValueProtocol = { + deviceId: { + type: String, + required: true, + }, + serviceId: { + type: String, + required: true, + }, + characteristicId: { + type: String, + required: true, + }, + }; + const API_WRITE_BLE_CHARACTERISTIC_VALUE = 'writeBLECharacteristicValue'; + const WriteBLECharacteristicValueProtocol = { + deviceId: { + type: String, + required: true, + }, + serviceId: { + type: String, + required: true, + }, + characteristicId: { + type: String, + required: true, + }, + value: { + type: Array, + required: true, + }, + }; + const API_SET_BLE_MTU = 'setBLEMTU'; + const SetBLEMTUProtocol = { + deviceId: { + type: String, + required: true, + }, + mtu: { + type: Number, + required: true, + }, + }; + const API_GET_BLE_DEVICE_RSSI = 'getBLEDeviceRSSI'; + const GetBLEDeviceRSSIProtocol = { + deviceId: { + type: String, + required: true, + }, + }; + + const API_ON_BEACON_UPDATE = 'onBeaconUpdate'; + const API_ON_BEACON_SERVICE_CHANGE = 'onBeaconServiceChange'; + const API_GET_BEACONS = 'getBeacons'; + const API_START_BEACON_DISCOVERY = 'startBeaconDiscovery'; + const StartBeaconDiscoveryProtocol = { + uuids: { + type: Array, + required: true, + }, + }; + const API_STOP_BEACON_DISCOVERY = 'stopBeaconDiscovery'; + + const API_GET_STORAGE = 'getStorage'; + const GetStorageProtocol = { + key: { + type: String, + required: true, + }, + }; + const API_GET_STORAGE_SYNC = 'getStorageSync'; + const GetStorageSyncProtocol = [ + { + name: 'key', + type: String, + required: true, + }, + ]; + const API_SET_STORAGE = 'setStorage'; + const SetStorageProtocol = { + key: { + type: String, + required: true, + }, + data: { + required: true, + }, + }; + const API_SET_STORAGE_SYNC = 'setStorageSync'; + const SetStorageSyncProtocol = [ + { + name: 'key', + type: String, + required: true, + }, + { + name: 'data', + required: true, + }, + ]; + const API_REMOVE_STORAGE = 'removeStorage'; + const RemoveStorageProtocol = GetStorageProtocol; + const RemoveStorageSyncProtocol = GetStorageSyncProtocol; + + const API_GET_FILE_INFO = 'getFileInfo'; + const GetFileInfoOptions = { + formatArgs: { + filePath(filePath, params) { + params.filePath = getRealPath(filePath); + }, + }, + }; + const GetFileInfoProtocol = { + filePath: { + type: String, + required: true, + }, + }; + + const API_OPEN_DOCUMENT = 'openDocument'; + const OpenDocumentOptions = { + formatArgs: { + filePath(filePath, params) { + params.filePath = getRealPath(filePath); + }, + }, + }; + const OpenDocumentProtocol = { + filePath: { + type: String, + required: true, + }, + fileType: String, + }; + + const API_HIDE_KEYBOARD = 'hideKeyboard'; + const API_SHOW_KEYBOARD = 'showKeyboard'; + + const API_GET_LOCATION = 'getLocation'; + const coordTypes = ['WGS84', 'GCJ02']; + const GetLocationOptions = { + formatArgs: { + type(value, params) { + value = (value || '').toUpperCase(); + if (coordTypes.indexOf(value) === -1) { + params.type = coordTypes[0]; + } + else { + params.type = value; + } + }, + altitude(value, params) { + params.altitude = value ? value : false; + }, + }, + }; + const GetLocationProtocol = { + type: String, + altitude: Boolean, + }; + + const API_GET_IMAGE_INFO = 'getImageInfo'; + const GetImageInfoOptions = { + formatArgs: { + src(src, params) { + params.src = getRealPath(src); + }, + }, + }; + const GetImageInfoProtocol = { + src: { + type: String, + required: true, + }, + }; + + const API_PREVIEW_IMAGE = 'previewImage'; + const PreviewImageOptions = { + formatArgs: { + urls(urls, params) { + params.urls = urls.map((url) => typeof url === 'string' && url ? getRealPath(url) : ''); + }, + current(current, params) { + if (typeof current === 'number') { + params.current = + current > 0 && current < params.urls.length ? current : 0; + } + else if (typeof current === 'string' && current) { + params.current = getRealPath(current); + } + }, + }, + }; + const PreviewImageProtocol = { + urls: { + type: Array, + required: true, + }, + current: { + type: [Number, String], + }, + }; + + const API_GET_VIDEO_INFO = 'getVideoInfo'; + const GetVideoInfoOptions = { + formatArgs: { + src(src, params) { + params.src = getRealPath(src); + }, + }, + }; + const GetVideoInfoProtocol = { + src: { + type: String, + required: true, + }, + }; + + const API_SAVE_IMAGE_TO_PHOTOS_ALBUM = 'saveImageToPhotosAlbum'; + const SaveImageToPhotosAlbumOptions = { + formatArgs: { + filePath(filePath, params) { + params.filePath = getRealPath(filePath); + }, + }, + }; + const SaveImageToPhotosAlbumProtocol = { + filePath: { + type: String, + required: true, + }, + }; + + const API_SAVE_VIDEO_TO_PHOTOS_ALBUM = 'saveVideoToPhotosAlbum'; + const SaveVideoToPhotosAlbumOptions = { + formatArgs: { + filePath(filePath, params) { + params.filePath = getRealPath(filePath); + }, + }, + }; + const SaveVideoToPhotosAlbumProtocol = { + filePath: { + type: String, + required: true, + }, + }; + + const API_GET_RECORDER_MANAGER = 'getRecorderManager'; + + const API_REQUEST = 'request'; + const dataType = { + JSON: 'json', + }; + const RESPONSE_TYPE = ['text', 'arraybuffer']; + const DEFAULT_RESPONSE_TYPE = 'text'; + const encode$1 = encodeURIComponent; + function stringifyQuery(url, data) { + let str = url.split('#'); + const hash = str[1] || ''; + str = str[0].split('?'); + let query = str[1] || ''; + url = str[0]; + const search = query.split('&').filter((item) => item); + const params = {}; + search.forEach((item) => { + const part = item.split('='); + params[part[0]] = part[1]; + }); + for (const key in data) { + if (hasOwn$1(data, key)) { + let v = data[key]; + if (typeof v === 'undefined' || v === null) { + v = ''; + } + else if (isPlainObject(v)) { + v = JSON.stringify(v); + } + params[encode$1(key)] = encode$1(v); + } + } + query = Object.keys(params) + .map((item) => `${item}=${params[item]}`) + .join('&'); + return url + (query ? '?' + query : '') + (hash ? '#' + hash : ''); + } + const RequestProtocol = { + method: String, + data: [Object, String, Array, ArrayBuffer], + url: { + type: String, + required: true, + }, + header: Object, + dataType: String, + responseType: String, + withCredentials: Boolean, + }; + const RequestOptions = { + formatArgs: { + method(value, params) { + params.method = elemInArray((value || '').toUpperCase(), HTTP_METHODS); + }, + data(value, params) { + params.data = value || ''; + }, + url(value, params) { + if (params.method === HTTP_METHODS[0] && + isPlainObject(params.data) && + Object.keys(params.data).length) { + // 将 method,data 校验提前,保证 url 校验时,method,data 已被格式化 + params.url = stringifyQuery(value, params.data); + } + }, + header(value, params) { + const header = (params.header = value || {}); + if (params.method !== HTTP_METHODS[0]) { + if (!Object.keys(header).find((key) => key.toLowerCase() === 'content-type')) { + header['Content-Type'] = 'application/json'; + } + } + }, + dataType(value, params) { + params.dataType = (value || dataType.JSON).toLowerCase(); + }, + responseType(value, params) { + params.responseType = (value || '').toLowerCase(); + if (RESPONSE_TYPE.indexOf(params.responseType) === -1) { + params.responseType = DEFAULT_RESPONSE_TYPE; + } + }, + }, + }; + + const API_DOWNLOAD_FILE = 'downloadFile'; + const DownloadFileOptions = { + formatArgs: { + header(value, params) { + params.header = value || {}; + }, + }, + }; + const DownloadFileProtocol = { + url: { + type: String, + required: true, + }, + header: Object, + timeout: Number, + }; + + const API_CONNECT_SOCKET = 'connectSocket'; + const ConnectSocketOptions = { + formatArgs: { + header(value, params) { + params.header = value || {}; + }, + method(value, params) { + params.method = elemInArray((value || '').toUpperCase(), HTTP_METHODS); + }, + protocols(protocols, params) { + if (typeof protocols === 'string') { + params.protocols = [protocols]; + } + }, + }, + }; + const ConnectSocketProtocol = { + url: { + type: String, + required: true, + }, + header: { + type: Object, + }, + method: String, + protocols: [Array, String], + }; + const API_SEND_SOCKET_MESSAGE = 'sendSocketMessage'; + const SendSocketMessageProtocol = { + data: [String, ArrayBuffer], + }; + const API_CLOSE_SOCKET = 'closeSocket'; + const CloseSocketProtocol = { + code: Number, + reason: String, + }; + + const API_HIDE_LOADING = 'hideLoading'; + + const API_HIDE_TOAST = 'hideToast'; + + const API_SHOW_ACTION_SHEET = 'showActionSheet'; + const ShowActionSheetProtocol = { + itemList: { + type: Array, + required: true, + }, + title: String, + alertText: String, + itemColor: String, + popover: Object, + }; + const ShowActionSheetOptions = { + formatArgs: { + itemColor: '#000', + }, + }; + + const API_SHOW_LOADING = 'showLoading'; + const ShowLoadingProtocol = { + title: String, + mask: Boolean, + }; + const ShowLoadingOptions = { + formatArgs: { + title: '', + mask: false, + }, + }; + + const API_SHOW_MODAL = 'showModal'; + const ShowModalProtocol = { + title: String, + content: String, + showCancel: Boolean, + cancelText: String, + cancelColor: String, + confirmText: String, + confirmColor: String, + }; + const ShowModalOptions = { + beforeInvoke() { + // dynamic init (tree shaking) + initI18nShowModalMsgsOnce(); + }, + formatArgs: { + title: '', + content: '', + showCancel: true, + cancelText(_value, params) { + if (!hasOwn$1(params, 'cancelText')) { + const { t } = useI18n(); + params.cancelText = t('uni.showModal.cancel'); + } + }, + cancelColor: '#000', + confirmText(_value, params) { + if (!hasOwn$1(params, 'confirmText')) { + const { t } = useI18n(); + params.confirmText = t('uni.showModal.confirm'); + } + }, + confirmColor: PRIMARY_COLOR, + }, + }; + + const API_SHOW_TOAST = 'showToast'; + const SHOW_TOAST_ICON = [ + 'success', + 'loading', + 'none', + 'error', + ]; + const ShowToastProtocol = { + title: String, + icon: String, + image: String, + duration: Number, + mask: Boolean, + }; + const ShowToastOptions = { + formatArgs: { + title: '', + icon(type, params) { + params.icon = elemInArray(type, SHOW_TOAST_ICON); + }, + image(value, params) { + if (value) { + params.image = getRealPath(value); + } + else { + params.image = ''; + } + }, + duration: 1500, + mask: false, + }, + }; + + const API_GET_PROVIDER = 'getProvider'; + const GetProviderProtocol = { + service: { + type: String, + required: true, + }, + }; + + function warpPlusSuccessCallback(resolve, after) { + return function successCallback(data) { + delete data.code; + delete data.message; + if (typeof after === 'function') { + data = after(data); + } + resolve(data); + }; + } + function warpPlusErrorCallback(reject, errMsg) { + return function errorCallback(error) { + error = error || {}; + // 一键登录errorCallback新增 appid、metadata、uid 参数返回 + errMsg = error.message || errMsg || ''; + delete error.message; + reject(errMsg, extend({ code: 0 }, error)); + }; + } + function warpPlusEvent(plusObject, event) { + return function () { + const object = plusObject(); + object(function (data) { + if (data) { + delete data.code; + delete data.message; + } + UniServiceJSBridge.invokeOnCallback(event, data); + }); + }; + } + function warpPlusMethod(plusObject, before, after) { + return function (options, { resolve, reject }) { + const object = plusObject(); + object(extend({}, typeof before === 'function' ? before(options) : options, { + success: warpPlusSuccessCallback(resolve, after), + fail: warpPlusErrorCallback(reject), + })); + }; + } + async function callApiSync(api, args, resolve, reject) { + api(args) + .then(() => { + resolve(); + }) + .catch((errMsg) => { + reject(errMsg); + }); + } + + const STORAGE_DATA_TYPE = '__TYPE'; + const STORAGE_KEYS = 'uni-storage-keys'; + function parseValue(value) { + const types = ['object', 'string', 'number', 'boolean', 'undefined']; + try { + const object = typeof value === 'string' ? JSON.parse(value) : value; + const type = object.type; + if (types.indexOf(type) >= 0) { + const keys = Object.keys(object); + if (keys.length === 2 && 'data' in object) { + // eslint-disable-next-line valid-typeof + if (typeof object.data === type) { + return object.data; + } + // eslint-disable-next-line no-useless-escape + if (type === 'object' && + /^\d{4}-\d{2}-\d{2}T\d{2}\:\d{2}\:\d{2}\.\d{3}Z$/.test(object.data)) { + // ISO 8601 格式返回 Date + return new Date(object.data); + } + } + else if (keys.length === 1) { + return ''; + } + } + } + catch (error) { } + } + const setStorageSync = defineSyncApi(API_SET_STORAGE_SYNC, (key, data) => { + const type = typeof data; + const value = type === 'string' + ? data + : JSON.stringify({ + type, + data: data, + }); + try { + if (type === 'string' && parseValue(value) !== undefined) { + plus.storage.setItem(key + STORAGE_DATA_TYPE, type); + } + else { + plus.storage.removeItem(key + STORAGE_DATA_TYPE); + } + plus.storage.setItem(key, value); + } + catch (error) { } + }, SetStorageSyncProtocol); + const setStorage = defineAsyncApi(API_SET_STORAGE, ({ key, data }, { resolve, reject }) => { + const type = typeof data; + const value = type === 'string' + ? data + : JSON.stringify({ + type, + data: data, + }); + try { + const storage = plus.storage; + if (type === 'string' && parseValue(value) !== undefined) { + storage.setItemAsync(key + STORAGE_DATA_TYPE, type); + } + else { + storage.removeItemAsync(key + STORAGE_DATA_TYPE); + } + storage.setItemAsync(key, value, resolve, warpPlusErrorCallback(reject)); + } + catch (error) { + reject(error.message); + } + }, SetStorageProtocol); + function parseGetStorage(type, value) { + let data = value; + if (type !== 'string' || + (type === 'string' && value === '{"type":"undefined"}')) { + try { + // 兼容H5和V3初期历史格式 + let object = JSON.parse(value); + const result = parseValue(object); + if (result !== undefined) { + data = result; + } + else if (type) { + // 兼容App端历史格式 + data = object; + if (typeof object === 'string') { + object = JSON.parse(object); + const objectType = typeof object; + if (objectType === 'number' && type === 'date') { + data = new Date(object); + } + else if (objectType === + (['null', 'array'].indexOf(type) < 0 ? type : 'object')) { + data = object; + } + } + } + } + catch (error) { } + } + return data; + } + const getStorageSync = defineSyncApi(API_GET_STORAGE_SYNC, (key, t) => { + const value = plus.storage.getItem(key); + const typeOrigin = plus.storage.getItem(key + STORAGE_DATA_TYPE) || ''; + const type = typeOrigin.toLowerCase(); + if (typeof value !== 'string') { + return ''; + } + return parseGetStorage(type, value); + }, GetStorageSyncProtocol); + const getStorage = defineAsyncApi(API_GET_STORAGE, ({ key }, { resolve, reject }) => { + const storage = plus.storage; + storage.getItemAsync(key, function (res) { + storage.getItemAsync(key + STORAGE_DATA_TYPE, function (typeRes) { + const typeOrigin = typeRes.data || ''; + const type = typeOrigin.toLowerCase(); + resolve({ + data: parseGetStorage(type, res.data), + }); + }, function () { + const type = ''; + resolve({ + data: parseGetStorage(type, res.data), + }); + }); + }, warpPlusErrorCallback(reject)); + }, GetStorageProtocol); + const removeStorageSync = defineSyncApi(API_REMOVE_STORAGE, (key) => { + plus.storage.removeItem(key + STORAGE_DATA_TYPE); + plus.storage.removeItem(key); + }, RemoveStorageSyncProtocol); + const removeStorage = defineAsyncApi(API_REMOVE_STORAGE, ({ key }, { resolve, reject }) => { + // 兼容App端历史格式 + plus.storage.removeItemAsync(key + STORAGE_DATA_TYPE); + plus.storage.removeItemAsync(key, resolve, warpPlusErrorCallback(reject)); + }, RemoveStorageProtocol); + const clearStorageSync = (defineSyncApi('clearStorageSync', () => { + plus.storage.clear(); + })); + const clearStorage = (defineAsyncApi('clearStorage', (_, { resolve, reject }) => { + plus.storage.clearAsync(resolve, warpPlusErrorCallback(reject)); + })); + const getStorageInfoSync = (defineSyncApi('getStorageInfoSync', () => { + const length = plus.storage.getLength() || 0; + const keys = []; + let currentSize = 0; + for (let index = 0; index < length; index++) { + const key = plus.storage.key(index); + if (key !== STORAGE_KEYS && + (key.indexOf(STORAGE_DATA_TYPE) < 0 || + key.indexOf(STORAGE_DATA_TYPE) + STORAGE_DATA_TYPE.length !== + key.length)) { + const value = plus.storage.getItem(key); + currentSize += key.length + value.length; + keys.push(key); + } + } + return { + keys, + currentSize: Math.ceil((currentSize * 2) / 1024), + limitSize: Number.MAX_VALUE, + }; + })); + const getStorageInfo = (defineAsyncApi('getStorageInfo', (_, { resolve }) => { + resolve(getStorageInfoSync()); + })); + + const getFileInfo = defineAsyncApi(API_GET_FILE_INFO, (options, { resolve, reject }) => { + plus.io.getFileInfo(extend(options, { + success: warpPlusSuccessCallback(resolve), + fail: warpPlusErrorCallback(reject), + })); + }, GetFileInfoProtocol, GetFileInfoOptions); + + const openDocument = defineAsyncApi(API_OPEN_DOCUMENT, ({ filePath, fileType }, { resolve, reject }) => { + plus.io.resolveLocalFileSystemURL(getRealPath(filePath), (entry) => { + plus.runtime.openFile(getRealPath(filePath)); + resolve(); + }, (err) => { + reject('openDocument:fail ' + err.message); + }); + }, OpenDocumentProtocol, OpenDocumentOptions); + + const DEVICE_FREQUENCY = 200; + const TEMP_PATH_BASE = '_doc/uniapp_temp'; + const TEMP_PATH = `${TEMP_PATH_BASE}_${Date.now()}`; + + let listener$1 = null; + const onCompassChange = (defineOnApi(API_ON_COMPASS, () => { + startCompass(); + })); + const offCompassChange = (defineOnApi(API_OFF_COMPASS, () => { + stopCompass(); + })); + const startCompass = (defineAsyncApi(API_START_COMPASS, (_, { resolve, reject }) => { + if (!listener$1) { + plus.orientation.watchOrientation((res) => { + UniServiceJSBridge.invokeOnCallback(API_ON_COMPASS, { + direction: res.magneticHeading, + }); + }, (err) => { + reject(err.message); + listener$1 = null; + }, { + frequency: DEVICE_FREQUENCY, + }); + } + setTimeout(resolve, DEVICE_FREQUENCY); + })); + const stopCompass = (defineAsyncApi(API_STOP_COMPASS, (_, { resolve }) => { + if (listener$1) { + plus.orientation.clearWatch(listener$1); + listener$1 = null; + } + resolve(); + })); + + const vibrateShort = defineAsyncApi(API_VIBRATE_SHORT, (_, { resolve }) => { + plus.device.vibrate(15); + resolve(); + }); + const vibrateLong = defineAsyncApi(API_VIBRATE_LONG, (_, { resolve }) => { + plus.device.vibrate(400); + resolve(); + }); + + let listener = null; + const onAccelerometerChange = (defineOnApi(API_ON_ACCELEROMETER, () => { + startAccelerometer(); + })); + const offAccelerometerChange = (defineOnApi(API_OFF_ACCELEROMETER, () => { + stopAccelerometer(); + })); + const startAccelerometer = (defineAsyncApi(API_START_ACCELEROMETER, (_, { resolve, reject }) => { + if (!listener) { + listener = plus.accelerometer.watchAcceleration((res) => { + UniServiceJSBridge.invokeOnCallback(API_ON_ACCELEROMETER, { + x: (res && res.xAxis) || 0, + y: (res && res.yAxis) || 0, + z: (res && res.zAxis) || 0, + }); + }, (err) => { + listener = null; + reject(`startAccelerometer:fail ${err.message}`); + }, { + frequency: DEVICE_FREQUENCY, + }); + } + setTimeout(resolve, DEVICE_FREQUENCY); + })); + const stopAccelerometer = (defineAsyncApi(API_STOP_ACCELEROMETER, (_, { resolve }) => { + if (listener) { + plus.accelerometer.clearWatch(listener); + listener = null; + } + resolve(); + })); + + const onBluetoothDeviceFound = defineOnApi(API_ON_BLUETOOTH_DEVICE_FOUND, warpPlusEvent(() => plus.bluetooth.onBluetoothDeviceFound, API_ON_BLUETOOTH_DEVICE_FOUND)); + const onBluetoothAdapterStateChange = defineOnApi(API_ON_BLUETOOTH_ADAPTER_STATE_CHANGE, warpPlusEvent(() => plus.bluetooth.onBluetoothAdapterStateChange, API_ON_BLUETOOTH_ADAPTER_STATE_CHANGE)); + const onBLEConnectionStateChange = defineOnApi(API_ON_BLE_CONNECTION_STATE_CHANGE, warpPlusEvent(() => plus.bluetooth.onBLEConnectionStateChange, API_ON_BLE_CONNECTION_STATE_CHANGE)); + const onBLECharacteristicValueChange = defineOnApi(API_ON_BLE_CHARACTERISTIC_VALUE_CHANGE, warpPlusEvent(() => plus.bluetooth.onBLECharacteristicValueChange, API_ON_BLE_CHARACTERISTIC_VALUE_CHANGE)); + const openBluetoothAdapter = defineAsyncApi('openBluetoothAdapter', warpPlusMethod(() => plus.bluetooth.openBluetoothAdapter)); + const closeBluetoothAdapter = defineAsyncApi('closeBluetoothAdapter', warpPlusMethod(() => plus.bluetooth.closeBluetoothAdapter)); + const getBluetoothAdapterState = defineAsyncApi('getBluetoothAdapterState', warpPlusMethod(() => plus.bluetooth.getBluetoothAdapterState)); + const startBluetoothDevicesDiscovery = defineAsyncApi(API_START_BLUETOOTH_DEVICES_DISCOVERY, warpPlusMethod(() => plus.bluetooth.startBluetoothDevicesDiscovery), StartBluetoothDevicesDiscoveryProtocol); + const stopBluetoothDevicesDiscovery = defineAsyncApi('stopBluetoothDevicesDiscovery', warpPlusMethod(() => plus.bluetooth.stopBluetoothDevicesDiscovery)); + const getBluetoothDevices = defineAsyncApi('getBluetoothDevices', warpPlusMethod(() => plus.bluetooth.getBluetoothDevices)); + const getConnectedBluetoothDevices = defineAsyncApi(API_GET_CONNECTED_BLUETOOTH_DEVICES, warpPlusMethod(() => plus.bluetooth.getConnectedBluetoothDevices), GetConnectedBluetoothDevicesProtocol); + const createBLEConnection = defineAsyncApi(API_CREATE_BLE_CONNECTION, warpPlusMethod(() => plus.bluetooth.createBLEConnection), CreateBLEConnectionProtocol); + const closeBLEConnection = defineAsyncApi(API_CLOSE_BLE_CONNECTION, warpPlusMethod(() => plus.bluetooth.closeBLEConnection), CloseBLEConnectionProtocol); + const getBLEDeviceServices = defineAsyncApi(API_GET_BLE_DEVICE_SERVICES, warpPlusMethod(() => plus.bluetooth.getBLEDeviceServices), GetBLEDeviceServicesProtocol); + const getBLEDeviceCharacteristics = defineAsyncApi(API_GET_BLE_DEVICE_CHARACTERISTICS, warpPlusMethod(() => plus.bluetooth.getBLEDeviceCharacteristics), GetBLEDeviceCharacteristicsProtocol); + const notifyBLECharacteristicValueChange = defineAsyncApi(API_NOTIFY_BLE_CHARACTERISTIC_VALUE_CHANGE, warpPlusMethod(() => plus.bluetooth.notifyBLECharacteristicValueChange), NotifyBLECharacteristicValueChangeProtocol); + const readBLECharacteristicValue = defineAsyncApi(API_READ_BLE_CHARACTERISTIC_VALUE, warpPlusMethod(() => plus.bluetooth.readBLECharacteristicValue), ReadBLECharacteristicValueProtocol); + const writeBLECharacteristicValue = defineAsyncApi(API_WRITE_BLE_CHARACTERISTIC_VALUE, warpPlusMethod(() => plus.bluetooth.writeBLECharacteristicValue), WriteBLECharacteristicValueProtocol); + const setBLEMTU = defineAsyncApi(API_SET_BLE_MTU, warpPlusMethod(() => plus.bluetooth.setBLEMTU), SetBLEMTUProtocol); + const getBLEDeviceRSSI = defineAsyncApi(API_GET_BLE_DEVICE_RSSI, warpPlusMethod(() => plus.bluetooth.getBLEDeviceRSSI), GetBLEDeviceRSSIProtocol); + + const onBeaconUpdate = defineOnApi(API_ON_BEACON_UPDATE, warpPlusEvent(() => plus.ibeacon.onBeaconUpdate, API_ON_BEACON_UPDATE)); + const onBeaconServiceChange = defineOnApi(API_ON_BEACON_SERVICE_CHANGE, warpPlusEvent(() => plus.ibeacon.onBeaconServiceChange, API_ON_BEACON_SERVICE_CHANGE)); + const getBeacons = defineAsyncApi(API_GET_BEACONS, warpPlusMethod(() => plus.ibeacon.getBeacons)); + const startBeaconDiscovery = defineAsyncApi(API_START_BEACON_DISCOVERY, warpPlusMethod(() => plus.ibeacon.startBeaconDiscovery), StartBeaconDiscoveryProtocol); + const stopBeaconDiscovery = defineAsyncApi(API_STOP_BEACON_DISCOVERY, warpPlusMethod(() => plus.ibeacon.stopBeaconDiscovery)); + + const makePhoneCall = defineAsyncApi(API_MAKE_PHONE_CALL, ({ phoneNumber }, { resolve }) => { + plus.device.dial(phoneNumber); + return resolve(); + }, MakePhoneCallProtocol); + + const getImageInfo = defineAsyncApi(API_GET_IMAGE_INFO, (options, { resolve, reject }) => { + const path = TEMP_PATH + '/download/'; + plus.io.getImageInfo(extend(options, { + savePath: path, + filename: path, + success: warpPlusSuccessCallback(resolve), + fail: warpPlusErrorCallback(reject), + })); + }, GetImageInfoProtocol, GetImageInfoOptions); + + const getVideoInfo = defineAsyncApi(API_GET_VIDEO_INFO, (options, { resolve, reject }) => { + plus.io.getVideoInfo({ + filePath: options.src, + success: (data) => { + return { + orientation: data.orientation, + type: data.type, + duration: data.duration, + size: data.size, + height: data.height, + width: data.width, + fps: data.fps || 30, + bitrate: data.bitrate, + }; + }, + fail: warpPlusErrorCallback(reject), + }); + }, GetVideoInfoProtocol, GetVideoInfoOptions); + + const previewImage = defineAsyncApi(API_PREVIEW_IMAGE, ({ current = 0, indicator = 'number', loop = false, urls, longPressActions }, { resolve, reject }) => { + initI18nChooseImageMsgsOnce(); + const { t } = useI18n(); + urls = urls.map((url) => getRealPath(url)); + const index = Number(current); + if (isNaN(index)) { + current = urls.indexOf(getRealPath(current)); + current = current < 0 ? 0 : current; + } + else { + current = index; + } + plus.nativeUI.previewImage(urls, { + current, + indicator, + loop, + onLongPress: function (res) { + let itemList = []; + let itemColor = ''; + const hasLongPressActions = longPressActions && isPlainObject(longPressActions); + if (!hasLongPressActions) { + itemList = [t('uni.previewImage.button.save')]; + itemColor = '#000000'; + } + else { + itemList = longPressActions.itemList + ? longPressActions.itemList + : []; + itemColor = longPressActions.itemColor + ? longPressActions.itemColor + : '#000000'; + } + const options = { + buttons: itemList.map((item) => ({ + title: item, + color: itemColor, + })), + cancel: t('uni.previewImage.cancel'), + }; + plus.nativeUI.actionSheet(options, (e) => { + if (e.index > 0) { + if (hasLongPressActions) { + typeof longPressActions.success === 'function' && + longPressActions.success({ + tapIndex: e.index - 1, + index: res.index, + }); + return; + } + plus.gallery.save(res.url, () => { + plus.nativeUI.toast(t('uni.previewImage.save.success')); + }, function () { + plus.nativeUI.toast(t('uni.previewImage.save.fail')); + }); + } + else if (hasLongPressActions) { + typeof longPressActions.fail === 'function' && + longPressActions.fail({ + errMsg: 'showActionSheet:fail cancel', + }); + } + }); + }, + }); + resolve(); + }, PreviewImageProtocol, PreviewImageOptions); + + let recorder; + let recording = false; + let recordTimeout; + const publishRecorderStateChange = (state, res = {}) => { + onRecorderStateChange(extend({ + state, + }, res)); + }; + const Recorder = { + start({ duration = 60000, sampleRate, numberOfChannels, encodeBitRate, format = 'mp3', frameSize, }) { + if (recording) { + return publishRecorderStateChange('start'); + } + recorder = plus.audio.getRecorder(); + recorder.record({ + format, + samplerate: String(sampleRate), + filename: TEMP_PATH + '/recorder/', + }, (res) => publishRecorderStateChange('stop', { + tempFilePath: res, + }), (err) => publishRecorderStateChange('error', { + errMsg: err.message, + })); + recordTimeout = setTimeout(() => { + Recorder.stop(); + }, duration); + publishRecorderStateChange('start'); + recording = true; + }, + stop() { + if (recording) { + recorder.stop(); + recording = false; + recordTimeout && clearTimeout(recordTimeout); + } + }, + pause() { + if (recording) { + publishRecorderStateChange('error', { + errMsg: 'Unsupported operation: pause', + }); + } + }, + resume() { + if (recording) { + publishRecorderStateChange('error', { + errMsg: 'Unsupported operation: resume', + }); + } + }, + }; + const callbacks$2 = { + pause: null, + resume: null, + start: null, + stop: null, + error: null, + }; + function onRecorderStateChange(res) { + const state = res.state; + delete res.state; + delete res.errMsg; + if (state && typeof callbacks$2[state] === 'function') { + callbacks$2[state](res); + } + } + class RecorderManager { + constructor() { } + onError(callback) { + callbacks$2.error = callback; + } + onFrameRecorded(callback) { } + onInterruptionBegin(callback) { } + onInterruptionEnd(callback) { } + onPause(callback) { + callbacks$2.pause = callback; + } + onResume(callback) { + callbacks$2.resume = callback; + } + onStart(callback) { + callbacks$2.start = callback; + } + onStop(callback) { + callbacks$2.stop = callback; + } + pause() { + Recorder.pause(); + } + resume() { + Recorder.resume(); + } + start(options) { + Recorder.start(options); + } + stop() { + Recorder.stop(); + } + } + let recorderManager; + const getRecorderManager = defineSyncApi(API_GET_RECORDER_MANAGER, () => recorderManager || (recorderManager = new RecorderManager())); + + const saveVideoToPhotosAlbum = defineAsyncApi(API_SAVE_VIDEO_TO_PHOTOS_ALBUM, (options, { resolve, reject }) => { + plus.gallery.save(options.filePath, warpPlusSuccessCallback(resolve), warpPlusErrorCallback(reject)); + }, SaveVideoToPhotosAlbumProtocol, SaveVideoToPhotosAlbumOptions); + + const saveImageToPhotosAlbum = defineAsyncApi(API_SAVE_IMAGE_TO_PHOTOS_ALBUM, (options, { resolve, reject }) => { + plus.gallery.save(options.filePath, warpPlusSuccessCallback(resolve), warpPlusErrorCallback(reject)); + }, SaveImageToPhotosAlbumProtocol, SaveImageToPhotosAlbumOptions); + + const showKeyboard = defineAsyncApi(API_SHOW_KEYBOARD, (_, { resolve }) => { + plus.key.showSoftKeybord(); + resolve(); + }); + const hideKeyboard = defineAsyncApi(API_HIDE_KEYBOARD, (_, { resolve }) => { + plus.key.hideSoftKeybord(); + resolve(); + }); + + class DownloadTask { + constructor(downloader) { + this._callbacks = []; + this._downloader = downloader; + downloader.addEventListener('statechanged', (download, status) => { + if (download.downloadedSize && download.totalSize) { + this._callbacks.forEach((callback) => { + callback({ + progress: Math.round((download.downloadedSize / download.totalSize) * 100), + totalBytesWritten: download.downloadedSize, + totalBytesExpectedToWrite: download.totalSize, + }); + }); + } + }); + } + abort() { + this._downloader.abort(); + } + onProgressUpdate(callback) { + if (typeof callback !== 'function') { + return; + } + this._callbacks.push(callback); + } + offProgressUpdate(callback) { + const index = this._callbacks.indexOf(callback); + if (index >= 0) { + this._callbacks.splice(index, 1); + } + } + onHeadersReceived(callback) { + throw new Error('Method not implemented.'); + } + offHeadersReceived(callback) { + throw new Error('Method not implemented.'); + } + } + const downloadFile = defineTaskApi(API_DOWNLOAD_FILE, ({ url, header, timeout }, { resolve, reject }) => { + timeout = + (timeout || + (__uniConfig.networkTimeout && __uniConfig.networkTimeout.request) || + 60 * 1000) / 1000; + const downloader = plus.downloader.createDownload(url, { + timeout, + filename: TEMP_PATH + '/download/', + // 需要与其它平台上的表现保持一致，不走重试的逻辑。 + retry: 0, + retryInterval: 0, + }, (download, statusCode) => { + if (statusCode) { + resolve({ + tempFilePath: download.filename, + statusCode, + }); + } + else { + reject(`statusCode: ${statusCode}`); + } + }); + const downloadTask = new DownloadTask(downloader); + for (const name in header) { + if (hasOwn$1(header, name)) { + downloader.setRequestHeader(name, header[name]); + } + } + downloader.start(); + return downloadTask; + }, DownloadFileProtocol, DownloadFileOptions); + + function requireNativePlugin(pluginName) { + /* eslint-disable no-undef */ + if (typeof weex !== 'undefined') { + return weex.requireModule(pluginName); + } + /* eslint-disable no-undef */ + return __requireNativePlugin__(pluginName); + } + + const cookiesParse = (header) => { + let cookiesStr = header['Set-Cookie'] || header['set-cookie']; + let cookiesArr = []; + if (!cookiesStr) { + return []; + } + if (cookiesStr[0] === '[' && cookiesStr[cookiesStr.length - 1] === ']') { + cookiesStr = cookiesStr.slice(1, -1); + } + const handleCookiesArr = cookiesStr.split(';'); + for (let i = 0; i < handleCookiesArr.length; i++) { + if (handleCookiesArr[i].indexOf('Expires=') !== -1 || + handleCookiesArr[i].indexOf('expires=') !== -1) { + cookiesArr.push(handleCookiesArr[i].replace(',', '')); + } + else { + cookiesArr.push(handleCookiesArr[i]); + } + } + cookiesArr = cookiesArr.join(';').split(','); + return cookiesArr; + }; + function formatResponse(res, args) { + if (typeof res.data === 'string' && res.data.charCodeAt(0) === 65279) { + res.data = res.data.substr(1); + } + res.statusCode = parseInt(String(res.statusCode), 10); + if (isPlainObject(res.header)) { + res.header = Object.keys(res.header).reduce(function (ret, key) { + const value = res.header[key]; + if (Array.isArray(value)) { + ret[key] = value.join(','); + } + else if (typeof value === 'string') { + ret[key] = value; + } + return ret; + }, {}); + } + if (args.dataType && args.dataType.toLowerCase() === 'json') { + try { + res.data = JSON.parse(res.data); + } + catch (e) { } + } + return res; + } + /** + * 请求任务类 + */ + class RequestTask { + constructor(requestTask) { + this._requestTask = requestTask; + } + abort() { + this._requestTask.abort(); + } + offHeadersReceived() { } + onHeadersReceived() { } + } + const request = defineTaskApi(API_REQUEST, (args, { resolve, reject }) => { + let { header, method, data, timeout, url, responseType, sslVerify, firstIpv4, + // NOTE 属性有但是types没有 + // @ts-ignore + tls, } = args; + let contentType; + for (const name in header) { + if (name.toLowerCase() === 'content-type') { + contentType = header[name]; + break; + } + } + if (method !== 'GET' && + contentType.indexOf('application/json') === 0 && + isPlainObject(data)) { + data = JSON.stringify(data); + } + const stream = requireNativePlugin('stream'); + const headers = {}; + let abortTimeout; + let aborted; + let hasContentType = false; + for (const name in header) { + if (!hasContentType && name.toLowerCase() === 'content-type') { + hasContentType = true; + headers['Content-Type'] = header[name]; + // TODO 需要重构 + if (method !== 'GET' && + header[name].indexOf('application/x-www-form-urlencoded') === 0 && + typeof data !== 'string' && + !(data instanceof ArrayBuffer)) { + const bodyArray = []; + for (const key in data) { + if (hasOwn$1(data, key)) { + bodyArray.push(encodeURIComponent(key) + '=' + encodeURIComponent(data[key])); + } + } + data = bodyArray.join('&'); + } + } + else { + headers[name] = header[name]; + } + } + if (!hasContentType && method === 'POST') { + headers['Content-Type'] = + 'application/x-www-form-urlencoded; charset=UTF-8'; + } + if (timeout) { + abortTimeout = setTimeout(() => { + aborted = true; + reject('timeout'); + }, timeout + 200); // TODO +200 发消息到原生层有时间开销，以后考虑由原生层回调超时 + } + const options = { + method, + url: url.trim(), + // weex 官方文档有误，headers 类型实际 object，用 string 类型会无响应 + headers, + type: responseType === 'arraybuffer' ? 'base64' : 'text', + // weex 官方文档未说明实际支持 timeout，单位：ms + timeout: timeout || 6e5, + // 配置和weex模块内相反 + sslVerify: !sslVerify, + firstIpv4: firstIpv4, + tls, + }; + if (method !== 'GET') { + options.body = typeof data === 'string' ? data : JSON.stringify(data); + } + stream.fetch(options, ({ ok, status, data, headers, errorMsg, }) => { + if (aborted) { + return; + } + if (abortTimeout) { + clearTimeout(abortTimeout); + } + const statusCode = status; + if (statusCode > 0) { + resolve(formatResponse({ + data: ok && responseType === 'arraybuffer' + ? base64ToArrayBuffer(data) + : data, + statusCode, + header: headers, + cookies: cookiesParse(headers), + }, args)); + } + else { + let errMsg = 'abort statusCode:' + statusCode; + if (errorMsg) { + errMsg = errMsg + ' ' + errorMsg; + } + reject(errMsg); + } + }); + return new RequestTask({ + abort() { + aborted = true; + if (abortTimeout) { + clearTimeout(abortTimeout); + } + reject('abort'); + }, + }); + }, RequestProtocol, RequestOptions); + + const socketTasks = []; + const globalEvent = { + open: '', + close: '', + error: '', + message: '', + }; + let socket; + function createSocketTask(args) { + const socketId = String(Date.now()); + let errMsg; + try { + if (!socket) { + socket = requireNativePlugin('uni-webSocket'); + } + socket.WebSocket({ + id: socketId, + url: args.url, + protocol: Array.isArray(args.protocols) + ? args.protocols.join(',') + : args.protocols, + header: args.header, + }); + } + catch (error) { + errMsg = error; + } + return { socket, socketId, errMsg }; + } + class SocketTask { + constructor(socket, socketId) { + this.id = socketId; + this._socket = socket; + this._callbacks = { + open: [], + close: [], + error: [], + message: [], + }; + this.CLOSED = 3; + this.CLOSING = 2; + this.CONNECTING = 0; + this.OPEN = 1; + this.readyState = this.CLOSED; + if (!this._socket) + return; + this._socket.onopen(() => { + this.readyState = this.OPEN; + this.socketStateChange('open'); + }); + this._socket.onmessage((e) => { + this.socketStateChange('message', { + data: typeof e.data === 'object' + ? base64ToArrayBuffer(e.data.base64) + : e.data, + }); + }); + this._socket.onerror(() => { + this.onErrorOrClose(); + this.socketStateChange('error'); + }); + this._socket.onclose(() => { + this.onErrorOrClose(); + this.socketStateChange('close'); + }); + const oldSocketSend = this._socket.send; + const oldSocketClose = this._socket.close; + this._socket.send = (res) => { + oldSocketSend(extend({ + id: this.id, + data: typeof res.data === 'object' + ? { + '@type': 'binary', + base64: arrayBufferToBase64(res.data), + } + : res.data, + })); + }; + this._socket.close = (res) => { + oldSocketClose(extend({ + id: this.id, + res, + })); + }; + } + onErrorOrClose() { + this.readyState = this.CLOSED; + const index = socketTasks.indexOf(this); + if (index >= 0) { + socketTasks.splice(index, 1); + } + } + socketStateChange(name, res = {}) { + if (this === socketTasks[0] && globalEvent[name]) { + UniServiceJSBridge.invokeOnCallback(globalEvent[name], res); + } + // WYQ fix: App平台修复websocket onOpen时发送数据报错的Bug + this._callbacks[name].forEach((callback) => { + if (typeof callback === 'function') { + callback(name === 'message' ? res : {}); + } + }); + } + send(args) { + if (this.readyState !== this.OPEN) { + callOptions(args, 'sendSocketMessage:fail WebSocket is not connected'); + } + try { + this._socket.send({ + data: args.data, + }); + callOptions(args, 'sendSocketMessage:ok'); + } + catch (error) { + callOptions(args, `sendSocketMessage:fail ${error}`); + } + } + close(args) { + this.readyState = this.CLOSING; + try { + this._socket.close(args); + callOptions(args, 'closeSocket:ok'); + } + catch (error) { + callOptions(args, `closeSocket:fail ${error}`); + } + } + onOpen(callback) { + this._callbacks.open.push(callback); + } + onClose(callback) { + this._callbacks.close.push(callback); + } + onError(callback) { + this._callbacks.error.push(callback); + } + onMessage(callback) { + this._callbacks.message.push(callback); + } + } + const connectSocket = defineTaskApi(API_CONNECT_SOCKET, ({ url, protocols, header, method }, { resolve, reject }) => { + const { socket, socketId, errMsg } = createSocketTask({ + url, + protocols, + header, + method, + }); + const socketTask = new SocketTask(socket, socketId); + if (errMsg) { + setTimeout(() => { + reject(errMsg); + }, 0); + } + else { + socketTasks.push(socketTask); + } + setTimeout(() => { + resolve(); + }, 0); + return socketTask; + }, ConnectSocketProtocol, ConnectSocketOptions); + const sendSocketMessage = defineAsyncApi(API_SEND_SOCKET_MESSAGE, (args, { resolve, reject }) => { + const socketTask = socketTasks[0]; + if (!socketTask || socketTask.readyState !== socketTask.OPEN) { + reject('sendSocketMessage:fail WebSocket is not connected'); + return; + } + socketTask._socket.send({ + data: args.data, + }); + resolve(); + }, SendSocketMessageProtocol); + const closeSocket = defineAsyncApi(API_CLOSE_SOCKET, (args, { resolve, reject }) => { + const socketTask = socketTasks[0]; + if (!socketTask) { + reject('closeSocket:fail WebSocket is not connected'); + return; + } + socketTask.readyState = socketTask.CLOSING; + const { code, reason } = args; + socketTask._socket.close({ code, reason }); + resolve(); + }, CloseSocketProtocol); + function on(event) { + const api = `onSocket${capitalize(event)}`; + return defineOnApi(api, () => { + globalEvent[event] = api; + }); + } + const onSocketOpen = /*#__PURE__*/ on('open'); + const onSocketError = /*#__PURE__*/ on('error'); + const onSocketMessage = /*#__PURE__*/ on('message'); + const onSocketClose = /*#__PURE__*/ on('close'); + + const audios = {}; + const evts = [ + 'play', + 'canplay', + 'ended', + 'stop', + 'waiting', + 'seeking', + 'seeked', + 'pause', + ]; + const initStateChage = (audioId) => { + const audio = audios[audioId]; + if (!audio) { + return; + } + if (!audio.initStateChage) { + audio.initStateChage = true; + audio.addEventListener('error', (error) => { + onAudioStateChange({ + state: 'error', + audioId, + errMsg: 'MediaError', + errCode: error.code, + }); + }); + evts.forEach((event) => { + audio.addEventListener(event, () => { + // 添加 isStopped 属性是为了解决 安卓设备停止播放后获取播放进度不正确的问题 + if (event === 'play') { + audio.isStopped = false; + } + else if (event === 'stop') { + audio.isStopped = true; + } + onAudioStateChange({ + state: event, + audioId, + }); + }); + }); + } + }; + function createAudioInstance() { + const audioId = `${Date.now()}${Math.random()}`; + const audio = (audios[audioId] = plus.audio.createPlayer()); + audio.src = ''; + audio.volume = 1; + audio.startTime = 0; + return { + errMsg: 'createAudioInstance:ok', + audioId, + }; + } + function setAudioState({ audioId, src, startTime, autoplay = false, loop = false, obeyMuteSwitch, volume, }) { + const audio = audios[audioId]; + if (audio) { + const style = { + loop, + autoplay, + }; + if (src) { + audio.src = style.src = getRealPath(src); + } + if (startTime) { + audio.startTime = style.startTime = startTime; + } + if (typeof volume === 'number') { + audio.volume = style.volume = volume; + } + audio.setStyles(style); + initStateChage(audioId); + } + return { + errMsg: 'setAudioState:ok', + }; + } + function getAudioState({ audioId }) { + const audio = audios[audioId]; + if (!audio) { + return { + errMsg: 'getAudioState:fail', + }; + } + const { src, startTime, volume } = audio; + return { + errMsg: 'getAudioState:ok', + duration: 1e3 * (audio.getDuration() || 0), + currentTime: audio.isStopped ? 0 : 1e3 * audio.getPosition(), + paused: audio.isPaused(), + src, + volume, + startTime: 1e3 * startTime, + buffered: 1e3 * audio.getBuffered(), + }; + } + function operateAudio({ operationType, audioId, currentTime, }) { + const audio = audios[audioId]; + switch (operationType) { + case 'play': + case 'pause': + case 'stop': + audio[operationType === 'play' && audio.isPaused() ? 'resume' : operationType](); + break; + case 'seek': + typeof currentTime != 'undefined' ? audio.seekTo(currentTime / 1e3) : ''; + break; + } + return { + errMsg: 'operateAudio:ok', + }; + } + const innerAudioContexts = Object.create(null); + const onAudioStateChange = ({ state, audioId, errMsg, errCode, }) => { + const audio = innerAudioContexts[audioId]; + if (audio) { + emit(audio, state, errMsg, errCode); + if (state === 'play') { + const oldCurrentTime = audio.currentTime; + audio.__timing = setInterval(() => { + const currentTime = audio.currentTime; + if (currentTime !== oldCurrentTime) { + emit(audio, 'timeupdate'); + } + }, 200); + } + else if (state === 'pause' || state === 'stop' || state === 'error') { + clearInterval(audio.__timing); + } + } + }; + const props$1 = [ + { + name: 'src', + cache: true, + }, + { + name: 'startTime', + default: 0, + cache: true, + }, + { + name: 'autoplay', + default: false, + cache: true, + }, + { + name: 'loop', + default: false, + cache: true, + }, + { + name: 'obeyMuteSwitch', + default: true, + readonly: true, + cache: true, + }, + { + name: 'duration', + readonly: true, + }, + { + name: 'currentTime', + readonly: true, + }, + { + name: 'paused', + readonly: true, + }, + { + name: 'buffered', + readonly: true, + }, + { + name: 'volume', + }, + ]; + class InnerAudioContext { + constructor(id) { + this.id = id; + this._callbacks = {}; + this._options = {}; + // 初始化事件监听列表 + innerAudioContextEventNames.forEach((eventName) => { + this._callbacks[eventName] = []; + }); + props$1.forEach((item) => { + const name = item.name; + Object.defineProperty(this, name, { + get: () => { + const result = item.cache + ? this._options + : getAudioState({ + audioId: this.id, + }); + const value = name in result ? result[name] : item.default; + return typeof value === 'number' && name !== 'volume' + ? value / 1e3 + : value; + }, + set: item.readonly + ? undefined + : (value) => { + this._options[name] = value; + setAudioState(extend({}, this._options, { + audioId: this.id, + })); + }, + }); + }); + initInnerAudioContextEventOnce(); + } + play() { + this._operate('play'); + } + pause() { + this._operate('pause'); + } + stop() { + this._operate('stop'); + } + seek(position) { + this._operate('seek', { + currentTime: position * 1e3, + }); + } + destroy() { + clearInterval(this.__timing); + if (audios[this.id]) { + audios[this.id].close(); + delete audios[this.id]; + } + delete innerAudioContexts[this.id]; + } + _operate(type, options) { + operateAudio(extend({}, options, { + audioId: this.id, + operationType: type, + })); + } + } + const initInnerAudioContextEventOnce = /*#__PURE__*/ once(() => { + // 批量设置音频上下文事件监听方法 + innerAudioContextEventNames.forEach((eventName) => { + InnerAudioContext.prototype[eventName] = function (callback) { + if (typeof callback === 'function') { + this._callbacks[eventName].push(callback); + } + }; + }); + // 批量设置音频上下文事件取消监听方法 + innerAudioContextOffEventNames.forEach((eventName) => { + InnerAudioContext.prototype[eventName] = function (callback) { + const callbacks = this._callbacks[eventName]; + const index = callbacks.indexOf(callback); + if (index >= 0) { + callbacks.splice(index, 1); + } + }; + }); + }); + function emit(audio, state, errMsg, errCode) { + const name = `on${state[0].toUpperCase() + state.substr(1)}`; + audio._callbacks[name].forEach((callback) => { + if (typeof callback === 'function') { + callback(state === 'error' + ? { + errMsg, + errCode, + } + : {}); + } + }); + } + /** + * 创建音频上下文 + */ + const createInnerAudioContext = defineSyncApi(API_CREATE_INNER_AUDIO_CONTEXT, () => { + const { audioId } = createAudioInstance(); + const innerAudioContext = new InnerAudioContext(audioId); + innerAudioContexts[audioId] = innerAudioContext; + return innerAudioContext; + }); + + const eventNames = [ + 'canplay', + 'play', + 'pause', + 'stop', + 'ended', + 'timeUpdate', + 'prev', + 'next', + 'error', + 'waiting', + ]; + const callbacks$1 = { + canplay: [], + play: [], + pause: [], + stop: [], + ended: [], + timeUpdate: [], + prev: [], + next: [], + error: [], + waiting: [], + }; + let audio; + let timeUpdateTimer = null; + const TIME_UPDATE = 250; + const events = ['play', 'pause', 'ended', 'stop', 'canplay']; + function startTimeUpdateTimer() { + stopTimeUpdateTimer(); + timeUpdateTimer = setInterval(() => { + onBackgroundAudioStateChange({ state: 'timeUpdate' }); + }, TIME_UPDATE); + } + function stopTimeUpdateTimer() { + if (timeUpdateTimer !== null) { + clearInterval(timeUpdateTimer); + } + } + function initMusic() { + if (audio) { + return; + } + const publish = UniServiceJSBridge.invokeOnCallback; + audio = plus.audio.createPlayer({ + autoplay: true, + backgroundControl: true, + }); + audio.src = + audio.title = + audio.epname = + audio.singer = + audio.coverImgUrl = + audio.webUrl = + ''; + audio.startTime = 0; + events.forEach((event) => { + audio.addEventListener(event, () => { + // 添加 isStopped 属性是为了解决 安卓设备停止播放后获取播放进度不正确的问题 + if (event === 'play') { + audio.isStopped = false; + startTimeUpdateTimer(); + } + else if (event === 'stop') { + audio.isStopped = true; + } + if (event === 'pause' || event === 'ended' || event === 'stop') { + stopTimeUpdateTimer(); + } + const eventName = `onMusic${event[0].toUpperCase() + event.substr(1)}`; + publish(eventName, { + dataUrl: audio.src, + errMsg: `${eventName}:ok`, + }); + onBackgroundAudioStateChange({ + state: event, + dataUrl: audio.src, + }); + }); + }); + audio.addEventListener('waiting', () => { + stopTimeUpdateTimer(); + onBackgroundAudioStateChange({ + state: 'waiting', + dataUrl: audio.src, + }); + }); + audio.addEventListener('error', (err) => { + stopTimeUpdateTimer(); + publish('onMusicError', { + dataUrl: audio.src, + errMsg: 'Error:' + err.message, + }); + onBackgroundAudioStateChange({ + state: 'error', + dataUrl: audio.src, + errMsg: err.message, + errCode: err.code, + }); + }); + // @ts-ignore + audio.addEventListener('prev', () => publish('onBackgroundAudioPrev')); + // @ts-ignore + audio.addEventListener('next', () => publish('onBackgroundAudioNext')); + } + function getBackgroundAudioState() { + let data = { + duration: 0, + currentTime: 0, + paused: false, + src: '', + buffered: 0, + title: '', + epname: '', + singer: '', + coverImgUrl: '', + webUrl: '', + startTime: 0, + errMsg: 'getBackgroundAudioState:ok', + }; + if (audio) { + const newData = { + duration: audio.getDuration() || 0, + currentTime: audio.isStopped ? 0 : audio.getPosition(), + paused: audio.isPaused(), + src: audio.src, + buffered: audio.getBuffered(), + title: audio.title, + epname: audio.epname, + singer: audio.singer, + coverImgUrl: audio.coverImgUrl, + webUrl: audio.webUrl, + startTime: audio.startTime, + }; + data = extend(data, newData); + } + return data; + } + function setMusicState(args) { + initMusic(); + const props = [ + 'src', + 'startTime', + 'coverImgUrl', + 'webUrl', + 'singer', + 'epname', + 'title', + ]; + const style = {}; + Object.keys(args).forEach((key) => { + if (props.indexOf(key) >= 0) { + let val = args[key]; + if (key === props[0] && val) { + val = getRealPath(val); + } + audio[key] = style[key] = val; + } + }); + audio.setStyles(style); + } + function operateMusicPlayer({ operationType, src, position, api = 'operateMusicPlayer', title, coverImgUrl, }) { + var operationTypes = ['resume', 'pause', 'stop']; + if (operationTypes.indexOf(operationType) > 0) { + audio && audio[operationType](); + } + else if (operationType === 'play') { + setMusicState({ + src, + startTime: position, + title, + coverImgUrl, + }); + audio.play(); + } + else if (operationType === 'seek') { + audio && audio.seekTo(position); + } + return { + errMsg: `${api}:ok`, + }; + } + function operateBackgroundAudio({ operationType, src, startTime, currentTime, }) { + return operateMusicPlayer({ + operationType, + src, + position: startTime || currentTime || 0, + api: 'operateBackgroundAudio', + }); + } + function onBackgroundAudioStateChange({ state, errMsg, errCode, dataUrl, }) { + callbacks$1[state].forEach((callback) => { + if (typeof callback === 'function') { + callback(state === 'error' + ? { + errMsg, + errCode, + } + : {}); + } + }); + } + const onInitBackgroundAudioManager = /*#__PURE__*/ once(() => { + eventNames.forEach((item) => { + const name = item[0].toUpperCase() + item.substr(1); + BackgroundAudioManager.prototype[`on${name}`] = function (callback) { + callbacks$1[item].push(callback); + }; + }); + }); + const props = [ + { + name: 'duration', + readonly: true, + }, + { + name: 'currentTime', + readonly: true, + }, + { + name: 'paused', + readonly: true, + }, + { + name: 'src', + cache: true, + }, + { + name: 'startTime', + default: 0, + cache: true, + }, + { + name: 'buffered', + readonly: true, + }, + { + name: 'title', + cache: true, + }, + { + name: 'epname', + cache: true, + }, + { + name: 'singer', + cache: true, + }, + { + name: 'coverImgUrl', + cache: true, + }, + { + name: 'webUrl', + cache: true, + }, + { + name: 'protocol', + readonly: true, + default: 'http', + }, + ]; + class BackgroundAudioManager { + constructor() { + this._options = {}; + props.forEach((item) => { + const name = item.name; + Object.defineProperty(this, name, { + get: () => { + const result = item.cache ? this._options : getBackgroundAudioState(); + return name in result ? result[name] : item.default; + }, + set: item.readonly + ? undefined + : (value) => { + this._options[name] = value; + setMusicState(this._options); + }, + }); + }); + onInitBackgroundAudioManager(); + } + play() { + this._operate('play'); + } + pause() { + this._operate('pause'); + } + stop() { + this._operate('stop'); + } + seek(position) { + this._operate('seek', { + currentTime: position, + }); + } + _operate(type, options) { + operateBackgroundAudio(extend({}, options, { + operationType: type, + })); + } + } + let backgroundAudioManager; + const getBackgroundAudioManager = defineSyncApi(API_GET_BACKGROUND_AUDIO_MANAGER, () => backgroundAudioManager || + (backgroundAudioManager = new BackgroundAudioManager())); + + const PI = 3.1415926535897932384626; + const a = 6378245.0; + const ee = 0.00669342162296594323; + function gcj02towgs84(lng, lat) { + lat = +lat; + lng = +lng; + if (outOfChina(lng, lat)) { + return [lng, lat]; + } + let dlat = _transformlat(lng - 105.0, lat - 35.0); + let dlng = _transformlng(lng - 105.0, lat - 35.0); + const radlat = (lat / 180.0) * PI; + let magic = Math.sin(radlat); + magic = 1 - ee * magic * magic; + const sqrtmagic = Math.sqrt(magic); + dlat = (dlat * 180.0) / (((a * (1 - ee)) / (magic * sqrtmagic)) * PI); + dlng = (dlng * 180.0) / ((a / sqrtmagic) * Math.cos(radlat) * PI); + const mglat = lat + dlat; + const mglng = lng + dlng; + return [lng * 2 - mglng, lat * 2 - mglat]; + } + function wgs84togcj02(lng, lat) { + lat = +lat; + lng = +lng; + if (outOfChina(lng, lat)) { + return [lng, lat]; + } + let dlat = _transformlat(lng - 105.0, lat - 35.0); + let dlng = _transformlng(lng - 105.0, lat - 35.0); + const radlat = (lat / 180.0) * PI; + let magic = Math.sin(radlat); + magic = 1 - ee * magic * magic; + const sqrtmagic = Math.sqrt(magic); + dlat = (dlat * 180.0) / (((a * (1 - ee)) / (magic * sqrtmagic)) * PI); + dlng = (dlng * 180.0) / ((a / sqrtmagic) * Math.cos(radlat) * PI); + const mglat = lat + dlat; + const mglng = lng + dlng; + return [mglng, mglat]; + } + const outOfChina = function (lng, lat) { + return (lng < 72.004 || lng > 137.8347 || lat < 0.8293 || lat > 55.8271 || false); + }; + const _transformlat = function (lng, lat) { + let ret = -100.0 + + 2.0 * lng + + 3.0 * lat + + 0.2 * lat * lat + + 0.1 * lng * lat + + 0.2 * Math.sqrt(Math.abs(lng)); + ret += + ((20.0 * Math.sin(6.0 * lng * PI) + 20.0 * Math.sin(2.0 * lng * PI)) * + 2.0) / + 3.0; + ret += + ((20.0 * Math.sin(lat * PI) + 40.0 * Math.sin((lat / 3.0) * PI)) * 2.0) / + 3.0; + ret += + ((160.0 * Math.sin((lat / 12.0) * PI) + 320 * Math.sin((lat * PI) / 30.0)) * + 2.0) / + 3.0; + return ret; + }; + const _transformlng = function (lng, lat) { + let ret = 300.0 + + lng + + 2.0 * lat + + 0.1 * lng * lng + + 0.1 * lng * lat + + 0.1 * Math.sqrt(Math.abs(lng)); + ret += + ((20.0 * Math.sin(6.0 * lng * PI) + 20.0 * Math.sin(2.0 * lng * PI)) * + 2.0) / + 3.0; + ret += + ((20.0 * Math.sin(lng * PI) + 40.0 * Math.sin((lng / 3.0) * PI)) * 2.0) / + 3.0; + ret += + ((150.0 * Math.sin((lng / 12.0) * PI) + + 300.0 * Math.sin((lng / 30.0) * PI)) * + 2.0) / + 3.0; + return ret; + }; + + function getLocationSuccess(type, position, resolve) { + const coords = position.coords; + if (type !== position.coordsType) { + if (process.env.NODE_ENV !== 'production') { + console.log(`UNIAPP[location]:before[${position.coordsType}][lng:${coords.longitude},lat:${coords.latitude}]`); + } + let coordArray; + if (type === 'wgs84') { + coordArray = gcj02towgs84(coords.longitude, coords.latitude); + } + else if (type === 'gcj02') { + coordArray = wgs84togcj02(coords.longitude, coords.latitude); + } + if (coordArray) { + coords.longitude = coordArray[0]; + coords.latitude = coordArray[1]; + if (process.env.NODE_ENV !== 'production') { + console.log(`UNIAPP[location]:after[${type}][lng:${coords.longitude},lat:${coords.latitude}]`); + } + } + } + resolve({ + type, + altitude: coords.altitude || 0, + latitude: coords.latitude, + longitude: coords.longitude, + speed: coords.speed, + accuracy: coords.accuracy, + address: position.address, + errMsg: 'getLocation:ok', + }); + } + const getLocation = defineAsyncApi(API_GET_LOCATION, ({ type = 'wgs84', geocode = false, altitude = false }, { resolve, reject }) => { + plus.geolocation.getCurrentPosition((position) => { + getLocationSuccess(type, position, resolve); + }, (e) => { + // 坐标地址解析失败 + if (e.code === 1501) { + getLocationSuccess(type, e, resolve); + return; + } + reject('getLocation:fail ' + e.message); + }, { + geocode: geocode, + enableHighAccuracy: altitude, + }); + }, GetLocationProtocol, GetLocationOptions); + + const showModal = defineAsyncApi(API_SHOW_MODAL, ({ title = '', content = '', showCancel = true, cancelText, cancelColor, confirmText, confirmColor, } = {}, { resolve }) => { + content = content || ' '; + plus.nativeUI.confirm(content, (e) => { + if (showCancel) { + resolve({ + confirm: e.index === 1, + cancel: e.index === 0 || e.index === -1, + }); + } + else { + resolve({ + confirm: e.index === 0, + cancel: false, + }); + } + }, title, showCancel ? [cancelText, confirmText] : [confirmText]); + }, ShowModalProtocol, ShowModalOptions); + + const showActionSheet = defineAsyncApi(API_SHOW_ACTION_SHEET, ({ itemList = [], itemColor = '#000000', title = '', alertText = '', popover, }, { resolve, reject }) => { + initI18nShowActionSheetMsgsOnce(); + const { t } = useI18n(); + const options = { + title, + cancel: t('uni.showActionSheet.cancel'), + buttons: itemList.map((item) => ({ + title: item, + color: itemColor, + })), + }; + if (title || alertText) { + options.title = alertText || title; + } + plus.nativeUI.actionSheet(extend(options, { + popover, + }), (e) => { + if (e.index > 0) { + resolve({ + tapIndex: e.index - 1, + }); + } + else { + reject('showActionSheet:fail cancel'); + } + }); + }, ShowActionSheetProtocol, ShowActionSheetOptions); + + let toast; + let isShowToast = false; + let toastType = ''; + let timeout; + const showLoading = defineAsyncApi(API_SHOW_LOADING, (args, { resolve, reject }) => { + callApiSync(showToast, extend({}, args, { + type: 'loading', + }), resolve, reject); + }, ShowLoadingProtocol, ShowLoadingOptions); + const hideLoading = defineAsyncApi(API_HIDE_LOADING, (_, { resolve, reject }) => { + callApiSync(hide, 'loading', resolve, reject); + }); + const showToast = defineAsyncApi(API_SHOW_TOAST, ({ title = '', icon = 'success', image = '', duration = 1500, mask = false, position, + // @ts-ignore ToastType + type = 'toast', + // @ts-ignore PlusNativeUIWaitingStyles + style, }, { resolve, reject }) => { + hide(''); + toastType = type; + if (['top', 'center', 'bottom'].includes(String(position))) { + // 仅可以关闭 richtext 类型，但 iOS 部分情况换行显示有问题 + plus.nativeUI.toast(title, { + verticalAlign: position, + }); + isShowToast = true; + } + else { + if (icon && !~['success', 'loading', 'error', 'none'].indexOf(icon)) { + icon = 'success'; + } + const waitingOptions = { + modal: mask, + back: 'transmit', + padding: '10px', + size: '16px', + }; + if (!image && (!icon || icon === 'none')) { + // 无图 + // waitingOptions.width = '120px' + // waitingOptions.height = '40px' + waitingOptions.loading = { + display: 'none', + }; + } + else { + waitingOptions.width = '140px'; + waitingOptions.height = '112px'; + } + if (image) { + waitingOptions.loading = { + display: 'block', + height: '55px', + icon: image, + interval: duration, + }; + } + else { + if (['success', 'error'].indexOf(icon) !== -1) { + waitingOptions.loading = { + display: 'block', + height: '55px', + icon: icon === 'success' ? '__uniappsuccess.png' : '__uniapperror.png', + interval: duration, + }; + } + } + try { + toast = plus.nativeUI.showWaiting(title, extend(waitingOptions, style)); + } + catch (error) { + reject(`${error}`); + } + } + timeout = setTimeout(() => { + hide(''); + }, duration); + return resolve(); + }, ShowToastProtocol, ShowToastOptions); + const hideToast = defineAsyncApi(API_HIDE_TOAST, (_, { resolve, reject }) => { + callApiSync(hide, 'toast', resolve, reject); + }); + function hide(type = 'toast') { + if (type && type !== toastType) { + return; + } + if (timeout) { + clearTimeout(timeout); + timeout = null; + } + if (isShowToast) { + plus.nativeUI.closeToast(); + } + else if (toast && toast.close) { + toast.close(); + } + toast = null; + isShowToast = false; + toastType = ''; + return { + errMsg: 'hide:ok', + }; + } + + const providers = { + oauth(callback) { + plus.oauth.getServices((services) => { + services = services; + const provider = []; + services.forEach(({ id }) => { + provider.push(id); + }); + callback(null, provider); + }, (err) => { + err = err; + callback(err); + }); + }, + share(callback) { + plus.share.getServices((services) => { + services = services; + const provider = []; + services.forEach(({ id }) => { + provider.push(id); + }); + callback(null, provider); + }, (err) => { + callback(err); + }); + }, + payment(callback) { + plus.payment.getChannels((services) => { + const provider = []; + services.forEach(({ id }) => { + provider.push(id); + }); + callback(null, provider); + }, (err) => { + callback(err); + }); + }, + push(callback) { + if (typeof weex !== 'undefined' || typeof plus !== 'undefined') { + callback(null, [plus.push.getClientInfo().id]); + } + else { + callback(null, []); + } + }, + }; + const getProvider = defineAsyncApi(API_GET_PROVIDER, ({ service }, { resolve, reject }) => { + if (providers[service]) { + providers[service]((err, provider) => { + if (err) { + reject(err.message); + } + else { + resolve({ + service, + provider: provider, + }); + } + }); + } + else { + reject('service not found'); + } + }, GetProviderProtocol); + + var uni$1 = /*#__PURE__*/Object.freeze({ + __proto__: null, + setStorageSync: setStorageSync, + setStorage: setStorage, + getStorageSync: getStorageSync, + getStorage: getStorage, + removeStorageSync: removeStorageSync, + removeStorage: removeStorage, + clearStorageSync: clearStorageSync, + clearStorage: clearStorage, + getStorageInfoSync: getStorageInfoSync, + getStorageInfo: getStorageInfo, + getFileInfo: getFileInfo, + openDocument: openDocument, + onCompassChange: onCompassChange, + offCompassChange: offCompassChange, + startCompass: startCompass, + stopCompass: stopCompass, + vibrateShort: vibrateShort, + vibrateLong: vibrateLong, + onAccelerometerChange: onAccelerometerChange, + offAccelerometerChange: offAccelerometerChange, + startAccelerometer: startAccelerometer, + stopAccelerometer: stopAccelerometer, + onBluetoothDeviceFound: onBluetoothDeviceFound, + onBluetoothAdapterStateChange: onBluetoothAdapterStateChange, + onBLEConnectionStateChange: onBLEConnectionStateChange, + onBLECharacteristicValueChange: onBLECharacteristicValueChange, + openBluetoothAdapter: openBluetoothAdapter, + closeBluetoothAdapter: closeBluetoothAdapter, + getBluetoothAdapterState: getBluetoothAdapterState, + startBluetoothDevicesDiscovery: startBluetoothDevicesDiscovery, + stopBluetoothDevicesDiscovery: stopBluetoothDevicesDiscovery, + getBluetoothDevices: getBluetoothDevices, + getConnectedBluetoothDevices: getConnectedBluetoothDevices, + createBLEConnection: createBLEConnection, + closeBLEConnection: closeBLEConnection, + getBLEDeviceServices: getBLEDeviceServices, + getBLEDeviceCharacteristics: getBLEDeviceCharacteristics, + notifyBLECharacteristicValueChange: notifyBLECharacteristicValueChange, + readBLECharacteristicValue: readBLECharacteristicValue, + writeBLECharacteristicValue: writeBLECharacteristicValue, + setBLEMTU: setBLEMTU, + getBLEDeviceRSSI: getBLEDeviceRSSI, + onBeaconUpdate: onBeaconUpdate, + onBeaconServiceChange: onBeaconServiceChange, + getBeacons: getBeacons, + startBeaconDiscovery: startBeaconDiscovery, + stopBeaconDiscovery: stopBeaconDiscovery, + makePhoneCall: makePhoneCall, + getImageInfo: getImageInfo, + getVideoInfo: getVideoInfo, + previewImage: previewImage, + getRecorderManager: getRecorderManager, + saveVideoToPhotosAlbum: saveVideoToPhotosAlbum, + saveImageToPhotosAlbum: saveImageToPhotosAlbum, + showKeyboard: showKeyboard, + hideKeyboard: hideKeyboard, + downloadFile: downloadFile, + request: request, + createSocketTask: createSocketTask, + connectSocket: connectSocket, + sendSocketMessage: sendSocketMessage, + closeSocket: closeSocket, + onSocketOpen: onSocketOpen, + onSocketError: onSocketError, + onSocketMessage: onSocketMessage, + onSocketClose: onSocketClose, + createInnerAudioContext: createInnerAudioContext, + getBackgroundAudioManager: getBackgroundAudioManager, + getLocation: getLocation, + showModal: showModal, + showActionSheet: showActionSheet, + showLoading: showLoading, + hideLoading: hideLoading, + showToast: showToast, + hideToast: hideToast, + hide: hide, + getProvider: getProvider + }); + + let isInitEntryPage = false; + function initEntry() { + if (isInitEntryPage) { + return; + } + isInitEntryPage = true; + let entryPagePath; + let entryPageQuery; + const weexPlus = weex.requireModule('plus'); + if (weexPlus.getRedirectInfo) { + const info = weexPlus.getRedirectInfo() || {}; + entryPagePath = info.path; + entryPageQuery = info.query ? '?' + info.query : ''; + } + else { + const argsJsonStr = plus.runtime.arguments; + if (!argsJsonStr) { + return; + } + try { + const args = JSON.parse(argsJsonStr); + entryPagePath = args.path || args.pathName; + entryPageQuery = args.query ? '?' + args.query : ''; + } + catch (e) { } + } + if (!entryPagePath || entryPagePath === __uniConfig.entryPagePath) { + if (entryPageQuery) { + __uniConfig.entryPageQuery = entryPageQuery; + } + return; + } + const entryRoute = '/' + entryPagePath; + const routeOptions = __uniRoutes.find((route) => route.path === entryRoute); + if (!routeOptions) { + return; + } + if (!routeOptions.meta.isTabBar) { + __uniConfig.realEntryPagePath = + __uniConfig.realEntryPagePath || __uniConfig.entryPagePath; + } + __uniConfig.entryPagePath = entryPagePath; + __uniConfig.entryPageQuery = entryPageQuery; + } + + const isIOS = plus.os.name === 'iOS'; + let config; + /** + * tabbar显示状态 + */ + let visible = true; + let tabBar; + /** + * 设置角标 + * @param {string} type + * @param {number} index + * @param {string} text + */ + function setTabBarBadge(type, index, text) { + if (!tabBar) { + return; + } + if (type === 'none') { + tabBar.hideTabBarRedDot({ + index, + }); + tabBar.removeTabBarBadge({ + index, + }); + } + else if (type === 'text') { + tabBar.setTabBarBadge({ + index, + text, + }); + } + else if (type === 'redDot') { + tabBar.showTabBarRedDot({ + index, + }); + } + } + /** + * 动态设置 tabBar 某一项的内容 + */ + function setTabBarItem(index, text, iconPath, selectedIconPath) { + const item = { + index, + }; + if (text !== undefined) { + item.text = text; + } + if (iconPath) { + item.iconPath = getRealPath(iconPath); + } + if (selectedIconPath) { + item.selectedIconPath = getRealPath(selectedIconPath); + } + tabBar && tabBar.setTabBarItem(item); + } + /** + * 动态设置 tabBar 的整体样式 + * @param {Object} style 样式 + */ + function setTabBarStyle(style) { + tabBar && tabBar.setTabBarStyle(style); + } + /** + * 隐藏 tabBar + * @param {boolean} animation 是否需要动画效果 + */ + function hideTabBar(animation) { + visible = false; + tabBar && + tabBar.hideTabBar({ + animation, + }); + } + /** + * 显示 tabBar + * @param {boolean} animation 是否需要动画效果 + */ + function showTabBar(animation) { + visible = true; + tabBar && + tabBar.showTabBar({ + animation, + }); + } + const maskClickCallback = []; + var tabBarInstance = { + id: '0', + init(options, clickCallback) { + if (options && options.list.length) { + config = options; + } + try { + tabBar = weex.requireModule('uni-tabview'); + } + catch (error) { + console.log(`uni.requireNativePlugin("uni-tabview") error ${error}`); + } + tabBar.onMaskClick(() => { + maskClickCallback.forEach((callback) => { + callback(); + }); + }); + tabBar && + tabBar.onClick(({ index }) => { + clickCallback(config.list[index], index); + }); + tabBar && + tabBar.onMidButtonClick(() => { + // publish('onTabBarMidButtonTap', {}) + }); + }, + indexOf(page) { + const itemLength = config && config.list && config.list.length; + if (itemLength) { + for (let i = 0; i < itemLength; i++) { + if (config.list[i].pagePath === page || + config.list[i].pagePath === `${page}.html`) { + return i; + } + } + } + return -1; + }, + switchTab(page) { + const index = this.indexOf(page); + if (index >= 0) { + tabBar && + tabBar.switchSelect({ + index, + }); + return true; + } + return false; + }, + setTabBarBadge, + setTabBarItem, + setTabBarStyle, + hideTabBar, + showTabBar, + append(webview) { + tabBar && + tabBar.append({ + id: webview.id, + }, ({ code }) => { + if (code !== 0) { + setTimeout(() => { + this.append(webview); + }, 20); + } + }); + }, + get visible() { + return visible; + }, + get height() { + return ((config && config.height ? parseFloat(config.height) : TABBAR_HEIGHT) + + plus.navigator.getSafeAreaInsets().deviceBottom); + }, + // tabBar是否遮挡内容区域 + get cover() { + const array = ['extralight', 'light', 'dark']; + return isIOS && array.indexOf(config.blurEffect) >= 0; + }, + setStyle({ mask }) { + tabBar.setMask({ + color: mask, + }); + }, + addEventListener(_name, callback) { + maskClickCallback.push(callback); + }, + removeEventListener(_name, callback) { + const callbackIndex = maskClickCallback.indexOf(callback); + maskClickCallback.splice(callbackIndex, 1); + }, + }; + + function initTabBar() { + const { tabBar } = __uniConfig; + const len = tabBar && tabBar.list && tabBar.list.length; + if (!len) { + return; + } + const { entryPagePath } = __uniConfig; + tabBar.selectedIndex = 0; + const selected = tabBar.list.findIndex((page) => page.pagePath === entryPagePath); + tabBarInstance.init(tabBar, (item, index) => { + uni.switchTab({ + url: '/' + item.pagePath, + openType: 'switchTab', + from: 'tabBar', + success() { + invokeHook('onTabItemTap', { + index, + text: item.text, + pagePath: item.pagePath, + }); + }, + }); + }); + if (selected !== -1) { + // 取当前 tab 索引值 + tabBar.selectedIndex = selected; + selected !== 0 && tabBarInstance.switchTab(entryPagePath); + } + } + + const callbacks = {}; + // 简单处理 view 层与 service 层的通知系统 + /** + * 消费 view 层通知 + */ + function consumePlusMessage(type, args) { + // 处理 web-view 组件发送的通知 + if (type === WEB_INVOKE_APPSERVICE) { + UniServiceJSBridge.emit('onWebInvokeAppService', args.data, args.webviewIds); + return true; + } + const callback = callbacks[type]; + if (callback) { + callback(args); + if (!callback.keepAlive) { + delete callbacks[type]; + } + return true; + } + return false; + } + + function backbuttonListener() { + uni.navigateBack({ + from: 'backbutton', + }); + } + + function initGlobalEvent() { + const plusGlobalEvent = plus.weexGlobalEvent; + const weexGlobalEvent = weex.requireModule('weexGlobalEvent'); + const emit = UniServiceJSBridge.emit; + if (weex.config.preload) { + plus.key.addEventListener('backbutton', backbuttonListener); + } + else { + plusGlobalEvent.addEventListener('splashclosed', () => { + plus.key.addEventListener('backbutton', backbuttonListener); + }); + } + plusGlobalEvent.addEventListener('pause', () => { + emit('onAppEnterBackground'); + }); + plusGlobalEvent.addEventListener('resume', () => { + emit('onAppEnterForeground'); + }); + weexGlobalEvent.addEventListener('uistylechange', function (event) { + const args = { + theme: event.uistyle, + }; + emit('onThemeChange', args); + }); + plusGlobalEvent.addEventListener('plusMessage', onPlusMessage); + // nvue webview post message + plusGlobalEvent.addEventListener('WebviewPostMessage', onPlusMessage); + } + function onPlusMessage(e) { + if (e.data && e.data.type) { + const type = e.data.type; + consumePlusMessage(type, e.data.args || {}); + } + } + + let appCtx; + const defaultApp = { + globalData: {}, + }; + function registerApp(appVm) { + appCtx = appVm; + appCtx.$vm = appVm; + extend(appCtx, defaultApp); // 拷贝默认实现 + const { $options } = appVm; + if ($options) { + appCtx.globalData = extend($options.globalData || {}, appCtx.globalData); + } + initEntry(); + initTabBar(); + initGlobalEvent(); + } + + function initRouteOptions(path, openType) { + // 需要序列化一遍 + const routeOptions = JSON.parse(JSON.stringify(__uniRoutes.find((route) => route.path === path))); + if (openType === 'reLaunch' || + (!__uniConfig.realEntryPagePath && getCurrentPages().length === 0) // redirectTo + ) { + routeOptions.meta.isQuit = true; + } + else if (!routeOptions.meta.isTabBar) { + routeOptions.meta.isQuit = false; + } + // TODO + // if (routeOptions.meta.isTabBar) { + // routeOptions.meta.visible = true + // } + return routeOptions; + } + + function initNVue(webviewStyle, routeMeta, path) { + if (path && routeMeta.isNVue) { + webviewStyle.uniNView = { + path, + defaultFontSize: __uniConfig.defaultFontSize, + viewport: __uniConfig.viewport, + }; + } + } + + const colorRE = /^#[a-z0-9]{6}$/i; + function isColor(color) { + return color && (colorRE.test(color) || color === 'transparent'); + } + + function initBackgroundColor(webviewStyle, routeMeta) { + const { backgroundColor } = routeMeta; + if (!backgroundColor) { + return; + } + if (!isColor(backgroundColor)) { + return; + } + if (!webviewStyle.background) { + webviewStyle.background = backgroundColor; + } + if (!webviewStyle.backgroundColorTop) { + webviewStyle.backgroundColorTop = backgroundColor; + } + } + + function initPopGesture(webviewStyle, routeMeta) { + // 不支持 hide + if (webviewStyle.popGesture === 'hide') { + delete webviewStyle.popGesture; + } + // 似乎没用了吧？记得是之前流应用时，需要 appback 的逻辑 + if (routeMeta.isQuit) { + webviewStyle.popGesture = (plus.os.name === 'iOS' ? 'appback' : 'none'); + } + } + + function initPullToRefresh(webviewStyle, routeMeta) { + if (!routeMeta.enablePullDownRefresh) { + return; + } + webviewStyle.pullToRefresh = normalizePullToRefreshRpx(extend({}, plus.os.name === 'Android' + ? defaultAndroidPullToRefresh + : defaultPullToRefresh, routeMeta.pullToRefresh)); + } + const defaultAndroidPullToRefresh = { support: true, style: 'circle' }; + const defaultPullToRefresh = { + support: true, + style: 'default', + height: '50px', + range: '200px', + contentdown: { + caption: '', + }, + contentover: { + caption: '', + }, + contentrefresh: { + caption: '', + }, + }; + + function initTitleNView(webviewStyle, routeMeta) { + const { navigationBar } = routeMeta; + if (navigationBar.style === 'custom') { + return false; + } + let autoBackButton = true; + if (routeMeta.isQuit) { + autoBackButton = false; + } + const titleNView = { + autoBackButton, + }; + Object.keys(navigationBar).forEach((name) => { + const value = navigationBar[name]; + if (name === 'backgroundColor') { + titleNView.backgroundColor = isColor(value) + ? value + : BACKGROUND_COLOR; + } + else if (name === 'titleImage' && value) { + titleNView.tags = createTitleImageTags(value); + } + else if (name === 'buttons' && isArray(value)) { + titleNView.buttons = value.map((button, index) => { + button.onclick = createTitleNViewBtnClick(index); + return button; + }); + } + }); + webviewStyle.titleNView = titleNView; + } + function createTitleImageTags(titleImage) { + return [ + { + tag: 'img', + src: titleImage, + position: { + left: 'auto', + top: 'auto', + width: 'auto', + height: '26px', + }, + }, + ]; + } + function createTitleNViewBtnClick(index) { + return function onClick(btn) { + btn.index = index; + invokeHook('onNavigationBarButtonTap', btn); + }; + } + + function parseWebviewStyle(id, path, routeOptions) { + const webviewStyle = { + bounce: 'vertical', + }; + const routeMeta = mergePageMeta(id, routeOptions.meta); + Object.keys(routeMeta).forEach((name) => { + if (WEBVIEW_STYLE_BLACKLIST.indexOf(name) === -1) { + webviewStyle[name] = + routeMeta[name]; + } + }); + initNVue(webviewStyle, routeMeta, path); + initPopGesture(webviewStyle, routeMeta); + initBackgroundColor(webviewStyle, routeMeta); + initTitleNView(webviewStyle, routeMeta); + initPullToRefresh(webviewStyle, routeMeta); + return webviewStyle; + } + const WEBVIEW_STYLE_BLACKLIST = [ + 'id', + 'route', + 'isNVue', + 'isQuit', + 'isEntry', + 'isTabBar', + 'tabBarIndex', + 'windowTop', + 'topWindow', + 'leftWindow', + 'rightWindow', + 'maxWidth', + 'usingComponents', + 'disableScroll', + 'enablePullDownRefresh', + 'navigationBar', + 'pullToRefresh', + 'onReachBottomDistance', + 'pageOrientation', + 'backgroundColor', + ]; + + let id = 2; + let preloadWebview; + function getWebviewId() { + return id; + } + function genWebviewId() { + return id++; + } + function getPreloadWebview() { + return preloadWebview; + } + function encode(val) { + return val; + } + function initUniPageUrl(path, query) { + const queryString = query ? stringifyQuery$1(query, encode) : ''; + return { + path: path.substr(1), + query: queryString ? queryString.substr(1) : queryString, + }; + } + + function createNVueWebview({ path, query, routeOptions, webviewStyle, }) { + const curWebviewId = genWebviewId(); + const curWebviewStyle = parseWebviewStyle(curWebviewId, path, routeOptions); + curWebviewStyle.uniPageUrl = initUniPageUrl(path, query); + if ((process.env.NODE_ENV !== 'production')) { + console.log('[uni-app] createWebview', curWebviewId, path, curWebviewStyle); + } + curWebviewStyle.isTab = !!routeOptions.meta.isTabBar; + return plus.webview.create('', String(curWebviewId), curWebviewStyle, extend({ + nvue: true, + }, webviewStyle)); + } + + function createWebview(options) { + if (options.routeOptions.meta.isNVue) { + return createNVueWebview(options); + } + if (getWebviewId() === 2) { + // 如果首页非 nvue，则直接返回 Launch Webview + return plus.webview.getLaunchWebview(); + } + return getPreloadWebview(); + } + + function registerPage({ path, query, openType, webview, }) { + // fast 模式，nvue 首页时，会在nvue中主动调用registerPage并传入首页webview，此时初始化一下首页（因为此时可能还未调用registerApp） + if (webview) { + initEntry(); + } + // TODO preloadWebview + const routeOptions = initRouteOptions(path, openType); + if (!webview) { + webview = createWebview({ path, routeOptions, query }); + } + else { + webview = plus.webview.getWebviewById(webview.id); + webview.nvue = routeOptions.meta.isNVue; + } + if ((process.env.NODE_ENV !== 'production')) { + console.log(`[uni-app] registerPage(${path},${webview.id})`); + } + } - var index = { - __registerApp: registerApp, - __registerPage: registerPage, - }; + // ;(uni as any).__$wx__ = uni + var index = { + uni: uni$1, + __registerApp: registerApp, + __registerPage: registerPage, + }; - return index; + return index; }()); const uni = serviceContext.uni; diff --git a/packages/uni-app-plus/dist/uni-app-view.umd.js b/packages/uni-app-plus/dist/uni-app-view.umd.js index 3e95926fb..cca5109e4 100644 --- a/packages/uni-app-plus/dist/uni-app-view.umd.js +++ b/packages/uni-app-plus/dist/uni-app-view.umd.js @@ -1,15 +1,4963 @@ -(function(global, factory) { - typeof exports === "object" && typeof module !== "undefined" ? factory(require("vue")) : typeof define === "function" && define.amd ? define(["vue"], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global.Vue)); -})(this, function(vue) { +(function(factory) { + typeof define === "function" && define.amd ? define(factory) : factory(); +})(function() { "use strict"; + (function() { + var n = window.Document.prototype.createElement, p2 = window.Document.prototype.createElementNS, aa = window.Document.prototype.importNode, ba = window.Document.prototype.prepend, ca = window.Document.prototype.append, da = window.DocumentFragment.prototype.prepend, ea = window.DocumentFragment.prototype.append, q = window.Node.prototype.cloneNode, r = window.Node.prototype.appendChild, t = window.Node.prototype.insertBefore, u = window.Node.prototype.removeChild, v = window.Node.prototype.replaceChild, w = Object.getOwnPropertyDescriptor(window.Node.prototype, "textContent"), y = window.Element.prototype.attachShadow, z = Object.getOwnPropertyDescriptor(window.Element.prototype, "innerHTML"), A = window.Element.prototype.getAttribute, B = window.Element.prototype.setAttribute, C = window.Element.prototype.removeAttribute, D = window.Element.prototype.getAttributeNS, E2 = window.Element.prototype.setAttributeNS, F = window.Element.prototype.removeAttributeNS, G = window.Element.prototype.insertAdjacentElement, H = window.Element.prototype.insertAdjacentHTML, fa = window.Element.prototype.prepend, ha = window.Element.prototype.append, ia = window.Element.prototype.before, ja = window.Element.prototype.after, ka = window.Element.prototype.replaceWith, la = window.Element.prototype.remove, ma = window.HTMLElement, I = Object.getOwnPropertyDescriptor(window.HTMLElement.prototype, "innerHTML"), na = window.HTMLElement.prototype.insertAdjacentElement, oa = window.HTMLElement.prototype.insertAdjacentHTML; + var pa = new Set(); + "annotation-xml color-profile font-face font-face-src font-face-uri font-face-format font-face-name missing-glyph".split(" ").forEach(function(a) { + return pa.add(a); + }); + function qa(a) { + var b = pa.has(a); + a = /^[a-z][.0-9_a-z]*-[-.0-9_a-z]*$/.test(a); + return !b && a; + } + var ra = document.contains ? document.contains.bind(document) : document.documentElement.contains.bind(document.documentElement); + function J(a) { + var b = a.isConnected; + if (b !== void 0) + return b; + if (ra(a)) + return true; + for (; a && !(a.__CE_isImportDocument || a instanceof Document); ) + a = a.parentNode || (window.ShadowRoot && a instanceof ShadowRoot ? a.host : void 0); + return !(!a || !(a.__CE_isImportDocument || a instanceof Document)); + } + function K(a) { + var b = a.children; + if (b) + return Array.prototype.slice.call(b); + b = []; + for (a = a.firstChild; a; a = a.nextSibling) + a.nodeType === Node.ELEMENT_NODE && b.push(a); + return b; + } + function L(a, b) { + for (; b && b !== a && !b.nextSibling; ) + b = b.parentNode; + return b && b !== a ? b.nextSibling : null; + } + function M(a, b, c) { + for (var f = a; f; ) { + if (f.nodeType === Node.ELEMENT_NODE) { + var d = f; + b(d); + var e = d.localName; + if (e === "link" && d.getAttribute("rel") === "import") { + f = d.import; + c === void 0 && (c = new Set()); + if (f instanceof Node && !c.has(f)) + for (c.add(f), f = f.firstChild; f; f = f.nextSibling) + M(f, b, c); + f = L(a, d); + continue; + } else if (e === "template") { + f = L(a, d); + continue; + } + if (d = d.__CE_shadowRoot) + for (d = d.firstChild; d; d = d.nextSibling) + M(d, b, c); + } + f = f.firstChild ? f.firstChild : L(a, f); + } + } + function N() { + var a = !(O === null || O === void 0 || !O.noDocumentConstructionObserver), b = !(O === null || O === void 0 || !O.shadyDomFastWalk); + this.h = []; + this.a = []; + this.f = false; + this.shadyDomFastWalk = b; + this.C = !a; + } + function P(a, b, c, f) { + var d = window.ShadyDom; + if (a.shadyDomFastWalk && d && d.inUse) { + if (b.nodeType === Node.ELEMENT_NODE && c(b), b.querySelectorAll) + for (a = d.nativeMethods.querySelectorAll.call(b, "*"), b = 0; b < a.length; b++) + c(a[b]); + } else + M(b, c, f); + } + function sa(a, b) { + a.f = true; + a.h.push(b); + } + function ta(a, b) { + a.f = true; + a.a.push(b); + } + function Q(a, b) { + a.f && P(a, b, function(c) { + return R(a, c); + }); + } + function R(a, b) { + if (a.f && !b.__CE_patched) { + b.__CE_patched = true; + for (var c = 0; c < a.h.length; c++) + a.h[c](b); + for (c = 0; c < a.a.length; c++) + a.a[c](b); + } + } + function S(a, b) { + var c = []; + P(a, b, function(d) { + return c.push(d); + }); + for (b = 0; b < c.length; b++) { + var f = c[b]; + f.__CE_state === 1 ? a.connectedCallback(f) : T(a, f); + } + } + function U(a, b) { + var c = []; + P(a, b, function(d) { + return c.push(d); + }); + for (b = 0; b < c.length; b++) { + var f = c[b]; + f.__CE_state === 1 && a.disconnectedCallback(f); + } + } + function V(a, b, c) { + c = c === void 0 ? {} : c; + var f = c.D, d = c.upgrade || function(g) { + return T(a, g); + }, e = []; + P(a, b, function(g) { + a.f && R(a, g); + if (g.localName === "link" && g.getAttribute("rel") === "import") { + var h2 = g.import; + h2 instanceof Node && (h2.__CE_isImportDocument = true, h2.__CE_registry = document.__CE_registry); + h2 && h2.readyState === "complete" ? h2.__CE_documentLoadHandled = true : g.addEventListener("load", function() { + var k = g.import; + if (!k.__CE_documentLoadHandled) { + k.__CE_documentLoadHandled = true; + var l = new Set(); + f && (f.forEach(function(m) { + return l.add(m); + }), l.delete(k)); + V(a, k, { D: l, upgrade: d }); + } + }); + } else + e.push(g); + }, f); + for (b = 0; b < e.length; b++) + d(e[b]); + } + function T(a, b) { + try { + var c = b.ownerDocument, f = c.__CE_registry; + var d = f && (c.defaultView || c.__CE_isImportDocument) ? W(f, b.localName) : void 0; + if (d && b.__CE_state === void 0) { + d.constructionStack.push(b); + try { + try { + if (new d.constructorFunction() !== b) + throw Error("The custom element constructor did not produce the element being upgraded."); + } finally { + d.constructionStack.pop(); + } + } catch (k) { + throw b.__CE_state = 2, k; + } + b.__CE_state = 1; + b.__CE_definition = d; + if (d.attributeChangedCallback && b.hasAttributes()) { + var e = d.observedAttributes; + for (d = 0; d < e.length; d++) { + var g = e[d], h2 = b.getAttribute(g); + h2 !== null && a.attributeChangedCallback(b, g, null, h2, null); + } + } + J(b) && a.connectedCallback(b); + } + } catch (k) { + X(k); + } + } + N.prototype.connectedCallback = function(a) { + var b = a.__CE_definition; + if (b.connectedCallback) + try { + b.connectedCallback.call(a); + } catch (c) { + X(c); + } + }; + N.prototype.disconnectedCallback = function(a) { + var b = a.__CE_definition; + if (b.disconnectedCallback) + try { + b.disconnectedCallback.call(a); + } catch (c) { + X(c); + } + }; + N.prototype.attributeChangedCallback = function(a, b, c, f, d) { + var e = a.__CE_definition; + if (e.attributeChangedCallback && -1 < e.observedAttributes.indexOf(b)) + try { + e.attributeChangedCallback.call(a, b, c, f, d); + } catch (g) { + X(g); + } + }; + function ua(a, b, c, f) { + var d = b.__CE_registry; + if (d && (f === null || f === "http://www.w3.org/1999/xhtml") && (d = W(d, c))) + try { + var e = new d.constructorFunction(); + if (e.__CE_state === void 0 || e.__CE_definition === void 0) + throw Error("Failed to construct '" + c + "': The returned value was not constructed with the HTMLElement constructor."); + if (e.namespaceURI !== "http://www.w3.org/1999/xhtml") + throw Error("Failed to construct '" + c + "': The constructed element's namespace must be the HTML namespace."); + if (e.hasAttributes()) + throw Error("Failed to construct '" + c + "': The constructed element must not have any attributes."); + if (e.firstChild !== null) + throw Error("Failed to construct '" + c + "': The constructed element must not have any children."); + if (e.parentNode !== null) + throw Error("Failed to construct '" + c + "': The constructed element must not have a parent node."); + if (e.ownerDocument !== b) + throw Error("Failed to construct '" + c + "': The constructed element's owner document is incorrect."); + if (e.localName !== c) + throw Error("Failed to construct '" + c + "': The constructed element's local name is incorrect."); + return e; + } catch (g) { + return X(g), b = f === null ? n.call(b, c) : p2.call(b, f, c), Object.setPrototypeOf(b, HTMLUnknownElement.prototype), b.__CE_state = 2, b.__CE_definition = void 0, R(a, b), b; + } + b = f === null ? n.call(b, c) : p2.call(b, f, c); + R(a, b); + return b; + } + function X(a) { + var b = a.message, c = a.sourceURL || a.fileName || "", f = a.line || a.lineNumber || 0, d = a.column || a.columnNumber || 0, e = void 0; + ErrorEvent.prototype.initErrorEvent === void 0 ? e = new ErrorEvent("error", { cancelable: true, message: b, filename: c, lineno: f, colno: d, error: a }) : (e = document.createEvent("ErrorEvent"), e.initErrorEvent("error", false, true, b, c, f), e.preventDefault = function() { + Object.defineProperty(this, "defaultPrevented", { configurable: true, get: function() { + return true; + } }); + }); + e.error === void 0 && Object.defineProperty(e, "error", { configurable: true, enumerable: true, get: function() { + return a; + } }); + window.dispatchEvent(e); + e.defaultPrevented || console.error(a); + } + function va() { + var a = this; + this.a = void 0; + this.w = new Promise(function(b) { + a.g = b; + }); + } + va.prototype.resolve = function(a) { + if (this.a) + throw Error("Already resolved."); + this.a = a; + this.g(a); + }; + function wa(a) { + var b = document; + this.g = void 0; + this.b = a; + this.a = b; + V(this.b, this.a); + this.a.readyState === "loading" && (this.g = new MutationObserver(this.A.bind(this)), this.g.observe(this.a, { childList: true, subtree: true })); + } + function xa(a) { + a.g && a.g.disconnect(); + } + wa.prototype.A = function(a) { + var b = this.a.readyState; + b !== "interactive" && b !== "complete" || xa(this); + for (b = 0; b < a.length; b++) + for (var c = a[b].addedNodes, f = 0; f < c.length; f++) + V(this.b, c[f]); + }; + function Y(a) { + this.j = new Map(); + this.l = new Map(); + this.u = new Map(); + this.o = false; + this.s = new Map(); + this.i = function(b) { + return b(); + }; + this.c = false; + this.m = []; + this.b = a; + this.v = a.C ? new wa(a) : void 0; + } + Y.prototype.B = function(a, b) { + var c = this; + if (!(b instanceof Function)) + throw new TypeError("Custom element constructor getters must be functions."); + ya(this, a); + this.j.set(a, b); + this.m.push(a); + this.c || (this.c = true, this.i(function() { + return za(c); + })); + }; + Y.prototype.define = function(a, b) { + var c = this; + if (!(b instanceof Function)) + throw new TypeError("Custom element constructors must be functions."); + ya(this, a); + Aa(this, a, b); + this.m.push(a); + this.c || (this.c = true, this.i(function() { + return za(c); + })); + }; + function ya(a, b) { + if (!qa(b)) + throw new SyntaxError("The element name '" + b + "' is not valid."); + if (W(a, b)) + throw Error("A custom element with name '" + (b + "' has already been defined.")); + if (a.o) + throw Error("A custom element is already being defined."); + } + function Aa(a, b, c) { + a.o = true; + var f; + try { + var d = c.prototype; + if (!(d instanceof Object)) + throw new TypeError("The custom element constructor's prototype is not an object."); + var e = function(m) { + var x = d[m]; + if (x !== void 0 && !(x instanceof Function)) + throw Error("The '" + m + "' callback must be a function."); + return x; + }; + var g = e("connectedCallback"); + var h2 = e("disconnectedCallback"); + var k = e("adoptedCallback"); + var l = (f = e("attributeChangedCallback")) && c.observedAttributes || []; + } catch (m) { + throw m; + } finally { + a.o = false; + } + c = { + localName: b, + constructorFunction: c, + connectedCallback: g, + disconnectedCallback: h2, + adoptedCallback: k, + attributeChangedCallback: f, + observedAttributes: l, + constructionStack: [] + }; + a.l.set(b, c); + a.u.set(c.constructorFunction, c); + return c; + } + Y.prototype.upgrade = function(a) { + V(this.b, a); + }; + function za(a) { + if (a.c !== false) { + a.c = false; + for (var b = [], c = a.m, f = new Map(), d = 0; d < c.length; d++) + f.set(c[d], []); + V(a.b, document, { upgrade: function(k) { + if (k.__CE_state === void 0) { + var l = k.localName, m = f.get(l); + m ? m.push(k) : a.l.has(l) && b.push(k); + } + } }); + for (d = 0; d < b.length; d++) + T(a.b, b[d]); + for (d = 0; d < c.length; d++) { + for (var e = c[d], g = f.get(e), h2 = 0; h2 < g.length; h2++) + T(a.b, g[h2]); + (e = a.s.get(e)) && e.resolve(void 0); + } + c.length = 0; + } + } + Y.prototype.get = function(a) { + if (a = W(this, a)) + return a.constructorFunction; + }; + Y.prototype.whenDefined = function(a) { + if (!qa(a)) + return Promise.reject(new SyntaxError("'" + a + "' is not a valid custom element name.")); + var b = this.s.get(a); + if (b) + return b.w; + b = new va(); + this.s.set(a, b); + var c = this.l.has(a) || this.j.has(a); + a = this.m.indexOf(a) === -1; + c && a && b.resolve(void 0); + return b.w; + }; + Y.prototype.polyfillWrapFlushCallback = function(a) { + this.v && xa(this.v); + var b = this.i; + this.i = function(c) { + return a(function() { + return b(c); + }); + }; + }; + function W(a, b) { + var c = a.l.get(b); + if (c) + return c; + if (c = a.j.get(b)) { + a.j.delete(b); + try { + return Aa(a, b, c()); + } catch (f) { + X(f); + } + } + } + window.CustomElementRegistry = Y; + Y.prototype.define = Y.prototype.define; + Y.prototype.upgrade = Y.prototype.upgrade; + Y.prototype.get = Y.prototype.get; + Y.prototype.whenDefined = Y.prototype.whenDefined; + Y.prototype.polyfillDefineLazy = Y.prototype.B; + Y.prototype.polyfillWrapFlushCallback = Y.prototype.polyfillWrapFlushCallback; + function Z(a, b, c) { + function f(d) { + return function(e) { + for (var g = [], h2 = 0; h2 < arguments.length; ++h2) + g[h2] = arguments[h2]; + h2 = []; + for (var k = [], l = 0; l < g.length; l++) { + var m = g[l]; + m instanceof Element && J(m) && k.push(m); + if (m instanceof DocumentFragment) + for (m = m.firstChild; m; m = m.nextSibling) + h2.push(m); + else + h2.push(m); + } + d.apply(this, g); + for (g = 0; g < k.length; g++) + U(a, k[g]); + if (J(this)) + for (g = 0; g < h2.length; g++) + k = h2[g], k instanceof Element && S(a, k); + }; + } + c.prepend !== void 0 && (b.prepend = f(c.prepend)); + c.append !== void 0 && (b.append = f(c.append)); + } + function Ba(a) { + Document.prototype.createElement = function(b) { + return ua(a, this, b, null); + }; + Document.prototype.importNode = function(b, c) { + b = aa.call(this, b, !!c); + this.__CE_registry ? V(a, b) : Q(a, b); + return b; + }; + Document.prototype.createElementNS = function(b, c) { + return ua(a, this, c, b); + }; + Z(a, Document.prototype, { prepend: ba, append: ca }); + } + function Ca(a) { + function b(f) { + return function(d) { + for (var e = [], g = 0; g < arguments.length; ++g) + e[g] = arguments[g]; + g = []; + for (var h2 = [], k = 0; k < e.length; k++) { + var l = e[k]; + l instanceof Element && J(l) && h2.push(l); + if (l instanceof DocumentFragment) + for (l = l.firstChild; l; l = l.nextSibling) + g.push(l); + else + g.push(l); + } + f.apply(this, e); + for (e = 0; e < h2.length; e++) + U(a, h2[e]); + if (J(this)) + for (e = 0; e < g.length; e++) + h2 = g[e], h2 instanceof Element && S(a, h2); + }; + } + var c = Element.prototype; + ia !== void 0 && (c.before = b(ia)); + ja !== void 0 && (c.after = b(ja)); + ka !== void 0 && (c.replaceWith = function(f) { + for (var d = [], e = 0; e < arguments.length; ++e) + d[e] = arguments[e]; + e = []; + for (var g = [], h2 = 0; h2 < d.length; h2++) { + var k = d[h2]; + k instanceof Element && J(k) && g.push(k); + if (k instanceof DocumentFragment) + for (k = k.firstChild; k; k = k.nextSibling) + e.push(k); + else + e.push(k); + } + h2 = J(this); + ka.apply(this, d); + for (d = 0; d < g.length; d++) + U(a, g[d]); + if (h2) + for (U(a, this), d = 0; d < e.length; d++) + g = e[d], g instanceof Element && S(a, g); + }); + la !== void 0 && (c.remove = function() { + var f = J(this); + la.call(this); + f && U(a, this); + }); + } + function Da(a) { + function b(d, e) { + Object.defineProperty(d, "innerHTML", { enumerable: e.enumerable, configurable: true, get: e.get, set: function(g) { + var h2 = this, k = void 0; + J(this) && (k = [], P(a, this, function(x) { + x !== h2 && k.push(x); + })); + e.set.call(this, g); + if (k) + for (var l = 0; l < k.length; l++) { + var m = k[l]; + m.__CE_state === 1 && a.disconnectedCallback(m); + } + this.ownerDocument.__CE_registry ? V(a, this) : Q(a, this); + return g; + } }); + } + function c(d, e) { + d.insertAdjacentElement = function(g, h2) { + var k = J(h2); + g = e.call(this, g, h2); + k && U(a, h2); + J(g) && S(a, h2); + return g; + }; + } + function f(d, e) { + function g(h2, k) { + for (var l = []; h2 !== k; h2 = h2.nextSibling) + l.push(h2); + for (k = 0; k < l.length; k++) + V(a, l[k]); + } + d.insertAdjacentHTML = function(h2, k) { + h2 = h2.toLowerCase(); + if (h2 === "beforebegin") { + var l = this.previousSibling; + e.call(this, h2, k); + g(l || this.parentNode.firstChild, this); + } else if (h2 === "afterbegin") + l = this.firstChild, e.call(this, h2, k), g(this.firstChild, l); + else if (h2 === "beforeend") + l = this.lastChild, e.call(this, h2, k), g(l || this.firstChild, null); + else if (h2 === "afterend") + l = this.nextSibling, e.call(this, h2, k), g(this.nextSibling, l); + else + throw new SyntaxError("The value provided (" + String(h2) + ") is not one of 'beforebegin', 'afterbegin', 'beforeend', or 'afterend'."); + }; + } + y && (Element.prototype.attachShadow = function(d) { + d = y.call(this, d); + if (a.f && !d.__CE_patched) { + d.__CE_patched = true; + for (var e = 0; e < a.h.length; e++) + a.h[e](d); + } + return this.__CE_shadowRoot = d; + }); + z && z.get ? b(Element.prototype, z) : I && I.get ? b(HTMLElement.prototype, I) : ta(a, function(d) { + b(d, { enumerable: true, configurable: true, get: function() { + return q.call(this, true).innerHTML; + }, set: function(e) { + var g = this.localName === "template", h2 = g ? this.content : this, k = p2.call(document, this.namespaceURI, this.localName); + for (k.innerHTML = e; 0 < h2.childNodes.length; ) + u.call(h2, h2.childNodes[0]); + for (e = g ? k.content : k; 0 < e.childNodes.length; ) + r.call(h2, e.childNodes[0]); + } }); + }); + Element.prototype.setAttribute = function(d, e) { + if (this.__CE_state !== 1) + return B.call(this, d, e); + var g = A.call(this, d); + B.call(this, d, e); + e = A.call(this, d); + a.attributeChangedCallback(this, d, g, e, null); + }; + Element.prototype.setAttributeNS = function(d, e, g) { + if (this.__CE_state !== 1) + return E2.call(this, d, e, g); + var h2 = D.call(this, d, e); + E2.call(this, d, e, g); + g = D.call(this, d, e); + a.attributeChangedCallback(this, e, h2, g, d); + }; + Element.prototype.removeAttribute = function(d) { + if (this.__CE_state !== 1) + return C.call(this, d); + var e = A.call(this, d); + C.call(this, d); + e !== null && a.attributeChangedCallback(this, d, e, null, null); + }; + Element.prototype.removeAttributeNS = function(d, e) { + if (this.__CE_state !== 1) + return F.call(this, d, e); + var g = D.call(this, d, e); + F.call(this, d, e); + var h2 = D.call(this, d, e); + g !== h2 && a.attributeChangedCallback(this, e, g, h2, d); + }; + na ? c(HTMLElement.prototype, na) : G && c(Element.prototype, G); + oa ? f(HTMLElement.prototype, oa) : H && f(Element.prototype, H); + Z(a, Element.prototype, { prepend: fa, append: ha }); + Ca(a); + } + var Ea = {}; + function Fa(a) { + function b() { + var c = this.constructor; + var f = document.__CE_registry.u.get(c); + if (!f) + throw Error("Failed to construct a custom element: The constructor was not registered with `customElements`."); + var d = f.constructionStack; + if (d.length === 0) + return d = n.call(document, f.localName), Object.setPrototypeOf(d, c.prototype), d.__CE_state = 1, d.__CE_definition = f, R(a, d), d; + var e = d.length - 1, g = d[e]; + if (g === Ea) + throw Error("Failed to construct '" + f.localName + "': This element was already constructed."); + d[e] = Ea; + Object.setPrototypeOf(g, c.prototype); + R(a, g); + return g; + } + b.prototype = ma.prototype; + Object.defineProperty(HTMLElement.prototype, "constructor", { writable: true, configurable: true, enumerable: false, value: b }); + window.HTMLElement = b; + } + function Ga(a) { + function b(c, f) { + Object.defineProperty(c, "textContent", { enumerable: f.enumerable, configurable: true, get: f.get, set: function(d) { + if (this.nodeType === Node.TEXT_NODE) + f.set.call(this, d); + else { + var e = void 0; + if (this.firstChild) { + var g = this.childNodes, h2 = g.length; + if (0 < h2 && J(this)) { + e = Array(h2); + for (var k = 0; k < h2; k++) + e[k] = g[k]; + } + } + f.set.call(this, d); + if (e) + for (d = 0; d < e.length; d++) + U(a, e[d]); + } + } }); + } + Node.prototype.insertBefore = function(c, f) { + if (c instanceof DocumentFragment) { + var d = K(c); + c = t.call(this, c, f); + if (J(this)) + for (f = 0; f < d.length; f++) + S(a, d[f]); + return c; + } + d = c instanceof Element && J(c); + f = t.call(this, c, f); + d && U(a, c); + J(this) && S(a, c); + return f; + }; + Node.prototype.appendChild = function(c) { + if (c instanceof DocumentFragment) { + var f = K(c); + c = r.call(this, c); + if (J(this)) + for (var d = 0; d < f.length; d++) + S(a, f[d]); + return c; + } + f = c instanceof Element && J(c); + d = r.call(this, c); + f && U(a, c); + J(this) && S(a, c); + return d; + }; + Node.prototype.cloneNode = function(c) { + c = q.call(this, !!c); + this.ownerDocument.__CE_registry ? V(a, c) : Q(a, c); + return c; + }; + Node.prototype.removeChild = function(c) { + var f = c instanceof Element && J(c), d = u.call(this, c); + f && U(a, c); + return d; + }; + Node.prototype.replaceChild = function(c, f) { + if (c instanceof DocumentFragment) { + var d = K(c); + c = v.call(this, c, f); + if (J(this)) + for (U(a, f), f = 0; f < d.length; f++) + S(a, d[f]); + return c; + } + d = c instanceof Element && J(c); + var e = v.call(this, c, f), g = J(this); + g && U(a, f); + d && U(a, c); + g && S(a, c); + return e; + }; + w && w.get ? b(Node.prototype, w) : sa(a, function(c) { + b(c, { enumerable: true, configurable: true, get: function() { + for (var f = [], d = this.firstChild; d; d = d.nextSibling) + d.nodeType !== Node.COMMENT_NODE && f.push(d.textContent); + return f.join(""); + }, set: function(f) { + for (; this.firstChild; ) + u.call(this, this.firstChild); + f != null && f !== "" && r.call(this, document.createTextNode(f)); + } }); + }); + } + var O = window.customElements; + function Ha() { + var a = new N(); + Fa(a); + Ba(a); + Z(a, DocumentFragment.prototype, { prepend: da, append: ea }); + Ga(a); + Da(a); + a = new Y(a); + document.__CE_registry = a; + Object.defineProperty(window, "customElements", { configurable: true, enumerable: true, value: a }); + } + O && !O.forcePolyfill && typeof O.define == "function" && typeof O.get == "function" || Ha(); + window.__CE_installPolyfill = Ha; + }).call(self); + function makeMap(str, expectsLowerCase) { + const map = Object.create(null); + const list = str.split(","); + for (let i = 0; i < list.length; i++) { + map[list[i]] = true; + } + return expectsLowerCase ? (val) => !!map[val.toLowerCase()] : (val) => !!map[val]; + } + const GLOBALS_WHITE_LISTED = "Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt"; + const isGloballyWhitelisted = /* @__PURE__ */ makeMap(GLOBALS_WHITE_LISTED); + const specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`; + const isSpecialBooleanAttr = /* @__PURE__ */ makeMap(specialBooleanAttrs); + function normalizeStyle(value) { + if (isArray(value)) { + const res = {}; + for (let i = 0; i < value.length; i++) { + const item = value[i]; + const normalized = normalizeStyle(isString$1(item) ? parseStringStyle(item) : item); + if (normalized) { + for (const key in normalized) { + res[key] = normalized[key]; + } + } + } + return res; + } else if (isObject$1(value)) { + return value; + } + } + const listDelimiterRE = /;(?![^(]*\))/g; + const propertyDelimiterRE = /:(.+)/; + function parseStringStyle(cssText) { + const ret = {}; + cssText.split(listDelimiterRE).forEach((item) => { + if (item) { + const tmp = item.split(propertyDelimiterRE); + tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim()); + } + }); + return ret; + } + function normalizeClass(value) { + let res = ""; + if (isString$1(value)) { + res = value; + } else if (isArray(value)) { + for (let i = 0; i < value.length; i++) { + const normalized = normalizeClass(value[i]); + if (normalized) { + res += normalized + " "; + } + } + } else if (isObject$1(value)) { + for (const name in value) { + if (value[name]) { + res += name + " "; + } + } + } + return res.trim(); + } + const EMPTY_OBJ = {}; + const EMPTY_ARR = []; + const NOOP = () => { + }; + const NO = () => false; + const onRE = /^on[^a-z]/; + const isOn = (key) => onRE.test(key); + const isModelListener = (key) => key.startsWith("onUpdate:"); + const extend$1 = Object.assign; + const remove = (arr, el) => { + const i = arr.indexOf(el); + if (i > -1) { + arr.splice(i, 1); + } + }; + const hasOwnProperty$1 = Object.prototype.hasOwnProperty; + const hasOwn$1 = (val, key) => hasOwnProperty$1.call(val, key); + const isArray = Array.isArray; + const isMap = (val) => toTypeString$1(val) === "[object Map]"; + const isSet = (val) => toTypeString$1(val) === "[object Set]"; + const isFunction = (val) => typeof val === "function"; + const isString$1 = (val) => typeof val === "string"; + const isSymbol = (val) => typeof val === "symbol"; + const isObject$1 = (val) => val !== null && typeof val === "object"; + const isPromise = (val) => { + return isObject$1(val) && isFunction(val.then) && isFunction(val.catch); + }; + const objectToString$1 = Object.prototype.toString; + const toTypeString$1 = (value) => objectToString$1.call(value); + const toRawType = (value) => { + return toTypeString$1(value).slice(8, -1); + }; + const isPlainObject$1 = (val) => toTypeString$1(val) === "[object Object]"; + const isIntegerKey = (key) => isString$1(key) && key !== "NaN" && key[0] !== "-" && "" + parseInt(key, 10) === key; + const isReservedProp = /* @__PURE__ */ makeMap(",key,ref,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted"); + const cacheStringFunction$1 = (fn) => { + const cache = Object.create(null); + return (str) => { + const hit = cache[str]; + return hit || (cache[str] = fn(str)); + }; + }; + const camelizeRE = /-(\w)/g; + const camelize = cacheStringFunction$1((str) => { + return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : ""); + }); + const hyphenateRE = /\B([A-Z])/g; + const hyphenate = cacheStringFunction$1((str) => str.replace(hyphenateRE, "-$1").toLowerCase()); + const capitalize = cacheStringFunction$1((str) => str.charAt(0).toUpperCase() + str.slice(1)); + const toHandlerKey = cacheStringFunction$1((str) => str ? `on${capitalize(str)}` : ``); + const hasChanged = (value, oldValue) => value !== oldValue && (value === value || oldValue === oldValue); + const invokeArrayFns = (fns, arg) => { + for (let i = 0; i < fns.length; i++) { + fns[i](arg); + } + }; + const def = (obj, key, value) => { + Object.defineProperty(obj, key, { + configurable: true, + enumerable: false, + value + }); + }; + const toNumber = (val) => { + const n = parseFloat(val); + return isNaN(n) ? val : n; + }; + const targetMap = new WeakMap(); + const effectStack = []; + let activeEffect; + const ITERATE_KEY = Symbol(""); + const MAP_KEY_ITERATE_KEY = Symbol(""); + function isEffect(fn) { + return fn && fn._isEffect === true; + } + function effect(fn, options = EMPTY_OBJ) { + if (isEffect(fn)) { + fn = fn.raw; + } + const effect2 = createReactiveEffect(fn, options); + if (!options.lazy) { + effect2(); + } + return effect2; + } + function stop(effect2) { + if (effect2.active) { + cleanup(effect2); + if (effect2.options.onStop) { + effect2.options.onStop(); + } + effect2.active = false; + } + } + let uid = 0; + function createReactiveEffect(fn, options) { + const effect2 = function reactiveEffect() { + if (!effect2.active) { + return fn(); + } + if (!effectStack.includes(effect2)) { + cleanup(effect2); + try { + enableTracking(); + effectStack.push(effect2); + activeEffect = effect2; + return fn(); + } finally { + effectStack.pop(); + resetTracking(); + activeEffect = effectStack[effectStack.length - 1]; + } + } + }; + effect2.id = uid++; + effect2.allowRecurse = !!options.allowRecurse; + effect2._isEffect = true; + effect2.active = true; + effect2.raw = fn; + effect2.deps = []; + effect2.options = options; + return effect2; + } + function cleanup(effect2) { + const { deps } = effect2; + if (deps.length) { + for (let i = 0; i < deps.length; i++) { + deps[i].delete(effect2); + } + deps.length = 0; + } + } + let shouldTrack = true; + const trackStack = []; + function pauseTracking() { + trackStack.push(shouldTrack); + shouldTrack = false; + } + function enableTracking() { + trackStack.push(shouldTrack); + shouldTrack = true; + } + function resetTracking() { + const last = trackStack.pop(); + shouldTrack = last === void 0 ? true : last; + } + function track(target, type, key) { + if (!shouldTrack || activeEffect === void 0) { + return; + } + let depsMap = targetMap.get(target); + if (!depsMap) { + targetMap.set(target, depsMap = new Map()); + } + let dep = depsMap.get(key); + if (!dep) { + depsMap.set(key, dep = new Set()); + } + if (!dep.has(activeEffect)) { + dep.add(activeEffect); + activeEffect.deps.push(dep); + } + } + function trigger(target, type, key, newValue, oldValue, oldTarget) { + const depsMap = targetMap.get(target); + if (!depsMap) { + return; + } + const effects = new Set(); + const add2 = (effectsToAdd) => { + if (effectsToAdd) { + effectsToAdd.forEach((effect2) => { + if (effect2 !== activeEffect || effect2.allowRecurse) { + effects.add(effect2); + } + }); + } + }; + if (type === "clear") { + depsMap.forEach(add2); + } else if (key === "length" && isArray(target)) { + depsMap.forEach((dep, key2) => { + if (key2 === "length" || key2 >= newValue) { + add2(dep); + } + }); + } else { + if (key !== void 0) { + add2(depsMap.get(key)); + } + switch (type) { + case "add": + if (!isArray(target)) { + add2(depsMap.get(ITERATE_KEY)); + if (isMap(target)) { + add2(depsMap.get(MAP_KEY_ITERATE_KEY)); + } + } else if (isIntegerKey(key)) { + add2(depsMap.get("length")); + } + break; + case "delete": + if (!isArray(target)) { + add2(depsMap.get(ITERATE_KEY)); + if (isMap(target)) { + add2(depsMap.get(MAP_KEY_ITERATE_KEY)); + } + } + break; + case "set": + if (isMap(target)) { + add2(depsMap.get(ITERATE_KEY)); + } + break; + } + } + const run = (effect2) => { + if (effect2.options.scheduler) { + effect2.options.scheduler(effect2); + } else { + effect2(); + } + }; + effects.forEach(run); + } + const isNonTrackableKeys = /* @__PURE__ */ makeMap(`__proto__,__v_isRef,__isVue`); + const builtInSymbols = new Set(Object.getOwnPropertyNames(Symbol).map((key) => Symbol[key]).filter(isSymbol)); + const get = /* @__PURE__ */ createGetter(); + const shallowGet = /* @__PURE__ */ createGetter(false, true); + const readonlyGet = /* @__PURE__ */ createGetter(true); + const shallowReadonlyGet = /* @__PURE__ */ createGetter(true, true); + const arrayInstrumentations = {}; + ["includes", "indexOf", "lastIndexOf"].forEach((key) => { + const method = Array.prototype[key]; + arrayInstrumentations[key] = function(...args) { + const arr = toRaw(this); + for (let i = 0, l = this.length; i < l; i++) { + track(arr, "get", i + ""); + } + const res = method.apply(arr, args); + if (res === -1 || res === false) { + return method.apply(arr, args.map(toRaw)); + } else { + return res; + } + }; + }); + ["push", "pop", "shift", "unshift", "splice"].forEach((key) => { + const method = Array.prototype[key]; + arrayInstrumentations[key] = function(...args) { + pauseTracking(); + const res = method.apply(this, args); + resetTracking(); + return res; + }; + }); + function createGetter(isReadonly2 = false, shallow = false) { + return function get2(target, key, receiver) { + if (key === "__v_isReactive") { + return !isReadonly2; + } else if (key === "__v_isReadonly") { + return isReadonly2; + } else if (key === "__v_raw" && receiver === (isReadonly2 ? shallow ? shallowReadonlyMap : readonlyMap : shallow ? shallowReactiveMap : reactiveMap).get(target)) { + return target; + } + const targetIsArray = isArray(target); + if (!isReadonly2 && targetIsArray && hasOwn$1(arrayInstrumentations, key)) { + return Reflect.get(arrayInstrumentations, key, receiver); + } + const res = Reflect.get(target, key, receiver); + if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) { + return res; + } + if (!isReadonly2) { + track(target, "get", key); + } + if (shallow) { + return res; + } + if (isRef(res)) { + const shouldUnwrap = !targetIsArray || !isIntegerKey(key); + return shouldUnwrap ? res.value : res; + } + if (isObject$1(res)) { + return isReadonly2 ? readonly(res) : reactive(res); + } + return res; + }; + } + const set = /* @__PURE__ */ createSetter(); + const shallowSet = /* @__PURE__ */ createSetter(true); + function createSetter(shallow = false) { + return function set2(target, key, value, receiver) { + let oldValue = target[key]; + if (!shallow) { + value = toRaw(value); + oldValue = toRaw(oldValue); + if (!isArray(target) && isRef(oldValue) && !isRef(value)) { + oldValue.value = value; + return true; + } + } + const hadKey = isArray(target) && isIntegerKey(key) ? Number(key) < target.length : hasOwn$1(target, key); + const result = Reflect.set(target, key, value, receiver); + if (target === toRaw(receiver)) { + if (!hadKey) { + trigger(target, "add", key, value); + } else if (hasChanged(value, oldValue)) { + trigger(target, "set", key, value); + } + } + return result; + }; + } + function deleteProperty(target, key) { + const hadKey = hasOwn$1(target, key); + target[key]; + const result = Reflect.deleteProperty(target, key); + if (result && hadKey) { + trigger(target, "delete", key, void 0); + } + return result; + } + function has(target, key) { + const result = Reflect.has(target, key); + if (!isSymbol(key) || !builtInSymbols.has(key)) { + track(target, "has", key); + } + return result; + } + function ownKeys(target) { + track(target, "iterate", isArray(target) ? "length" : ITERATE_KEY); + return Reflect.ownKeys(target); + } + const mutableHandlers = { + get, + set, + deleteProperty, + has, + ownKeys + }; + const readonlyHandlers = { + get: readonlyGet, + set(target, key) { + return true; + }, + deleteProperty(target, key) { + return true; + } + }; + const shallowReactiveHandlers = extend$1({}, mutableHandlers, { + get: shallowGet, + set: shallowSet + }); + extend$1({}, readonlyHandlers, { + get: shallowReadonlyGet + }); + const toReactive = (value) => isObject$1(value) ? reactive(value) : value; + const toReadonly = (value) => isObject$1(value) ? readonly(value) : value; + const toShallow = (value) => value; + const getProto = (v) => Reflect.getPrototypeOf(v); + function get$1(target, key, isReadonly2 = false, isShallow = false) { + target = target["__v_raw"]; + const rawTarget = toRaw(target); + const rawKey = toRaw(key); + if (key !== rawKey) { + !isReadonly2 && track(rawTarget, "get", key); + } + !isReadonly2 && track(rawTarget, "get", rawKey); + const { has: has2 } = getProto(rawTarget); + const wrap = isShallow ? toShallow : isReadonly2 ? toReadonly : toReactive; + if (has2.call(rawTarget, key)) { + return wrap(target.get(key)); + } else if (has2.call(rawTarget, rawKey)) { + return wrap(target.get(rawKey)); + } else if (target !== rawTarget) { + target.get(key); + } + } + function has$1(key, isReadonly2 = false) { + const target = this["__v_raw"]; + const rawTarget = toRaw(target); + const rawKey = toRaw(key); + if (key !== rawKey) { + !isReadonly2 && track(rawTarget, "has", key); + } + !isReadonly2 && track(rawTarget, "has", rawKey); + return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey); + } + function size(target, isReadonly2 = false) { + target = target["__v_raw"]; + !isReadonly2 && track(toRaw(target), "iterate", ITERATE_KEY); + return Reflect.get(target, "size", target); + } + function add(value) { + value = toRaw(value); + const target = toRaw(this); + const proto = getProto(target); + const hadKey = proto.has.call(target, value); + if (!hadKey) { + target.add(value); + trigger(target, "add", value, value); + } + return this; + } + function set$1(key, value) { + value = toRaw(value); + const target = toRaw(this); + const { has: has2, get: get2 } = getProto(target); + let hadKey = has2.call(target, key); + if (!hadKey) { + key = toRaw(key); + hadKey = has2.call(target, key); + } + const oldValue = get2.call(target, key); + target.set(key, value); + if (!hadKey) { + trigger(target, "add", key, value); + } else if (hasChanged(value, oldValue)) { + trigger(target, "set", key, value); + } + return this; + } + function deleteEntry(key) { + const target = toRaw(this); + const { has: has2, get: get2 } = getProto(target); + let hadKey = has2.call(target, key); + if (!hadKey) { + key = toRaw(key); + hadKey = has2.call(target, key); + } + get2 ? get2.call(target, key) : void 0; + const result = target.delete(key); + if (hadKey) { + trigger(target, "delete", key, void 0); + } + return result; + } + function clear() { + const target = toRaw(this); + const hadItems = target.size !== 0; + const result = target.clear(); + if (hadItems) { + trigger(target, "clear", void 0, void 0); + } + return result; + } + function createForEach(isReadonly2, isShallow) { + return function forEach(callback, thisArg) { + const observed = this; + const target = observed["__v_raw"]; + const rawTarget = toRaw(target); + const wrap = isShallow ? toShallow : isReadonly2 ? toReadonly : toReactive; + !isReadonly2 && track(rawTarget, "iterate", ITERATE_KEY); + return target.forEach((value, key) => { + return callback.call(thisArg, wrap(value), wrap(key), observed); + }); + }; + } + function createIterableMethod(method, isReadonly2, isShallow) { + return function(...args) { + const target = this["__v_raw"]; + const rawTarget = toRaw(target); + const targetIsMap = isMap(rawTarget); + const isPair = method === "entries" || method === Symbol.iterator && targetIsMap; + const isKeyOnly = method === "keys" && targetIsMap; + const innerIterator = target[method](...args); + const wrap = isShallow ? toShallow : isReadonly2 ? toReadonly : toReactive; + !isReadonly2 && track(rawTarget, "iterate", isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY); + return { + next() { + const { value, done } = innerIterator.next(); + return done ? { value, done } : { + value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value), + done + }; + }, + [Symbol.iterator]() { + return this; + } + }; + }; + } + function createReadonlyMethod(type) { + return function(...args) { + return type === "delete" ? false : this; + }; + } + const mutableInstrumentations = { + get(key) { + return get$1(this, key); + }, + get size() { + return size(this); + }, + has: has$1, + add, + set: set$1, + delete: deleteEntry, + clear, + forEach: createForEach(false, false) + }; + const shallowInstrumentations = { + get(key) { + return get$1(this, key, false, true); + }, + get size() { + return size(this); + }, + has: has$1, + add, + set: set$1, + delete: deleteEntry, + clear, + forEach: createForEach(false, true) + }; + const readonlyInstrumentations = { + get(key) { + return get$1(this, key, true); + }, + get size() { + return size(this, true); + }, + has(key) { + return has$1.call(this, key, true); + }, + add: createReadonlyMethod("add"), + set: createReadonlyMethod("set"), + delete: createReadonlyMethod("delete"), + clear: createReadonlyMethod("clear"), + forEach: createForEach(true, false) + }; + const shallowReadonlyInstrumentations = { + get(key) { + return get$1(this, key, true, true); + }, + get size() { + return size(this, true); + }, + has(key) { + return has$1.call(this, key, true); + }, + add: createReadonlyMethod("add"), + set: createReadonlyMethod("set"), + delete: createReadonlyMethod("delete"), + clear: createReadonlyMethod("clear"), + forEach: createForEach(true, true) + }; + const iteratorMethods = ["keys", "values", "entries", Symbol.iterator]; + iteratorMethods.forEach((method) => { + mutableInstrumentations[method] = createIterableMethod(method, false, false); + readonlyInstrumentations[method] = createIterableMethod(method, true, false); + shallowInstrumentations[method] = createIterableMethod(method, false, true); + shallowReadonlyInstrumentations[method] = createIterableMethod(method, true, true); + }); + function createInstrumentationGetter(isReadonly2, shallow) { + const instrumentations = shallow ? isReadonly2 ? shallowReadonlyInstrumentations : shallowInstrumentations : isReadonly2 ? readonlyInstrumentations : mutableInstrumentations; + return (target, key, receiver) => { + if (key === "__v_isReactive") { + return !isReadonly2; + } else if (key === "__v_isReadonly") { + return isReadonly2; + } else if (key === "__v_raw") { + return target; + } + return Reflect.get(hasOwn$1(instrumentations, key) && key in target ? instrumentations : target, key, receiver); + }; + } + const mutableCollectionHandlers = { + get: createInstrumentationGetter(false, false) + }; + const shallowCollectionHandlers = { + get: createInstrumentationGetter(false, true) + }; + const readonlyCollectionHandlers = { + get: createInstrumentationGetter(true, false) + }; + const reactiveMap = new WeakMap(); + const shallowReactiveMap = new WeakMap(); + const readonlyMap = new WeakMap(); + const shallowReadonlyMap = new WeakMap(); + function targetTypeMap(rawType) { + switch (rawType) { + case "Object": + case "Array": + return 1; + case "Map": + case "Set": + case "WeakMap": + case "WeakSet": + return 2; + default: + return 0; + } + } + function getTargetType(value) { + return value["__v_skip"] || !Object.isExtensible(value) ? 0 : targetTypeMap(toRawType(value)); + } + function reactive(target) { + if (target && target["__v_isReadonly"]) { + return target; + } + return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers, reactiveMap); + } + function shallowReactive(target) { + return createReactiveObject(target, false, shallowReactiveHandlers, shallowCollectionHandlers, shallowReactiveMap); + } + function readonly(target) { + return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers, readonlyMap); + } + function createReactiveObject(target, isReadonly2, baseHandlers, collectionHandlers, proxyMap) { + if (!isObject$1(target)) { + return target; + } + if (target["__v_raw"] && !(isReadonly2 && target["__v_isReactive"])) { + return target; + } + const existingProxy = proxyMap.get(target); + if (existingProxy) { + return existingProxy; + } + const targetType = getTargetType(target); + if (targetType === 0) { + return target; + } + const proxy = new Proxy(target, targetType === 2 ? collectionHandlers : baseHandlers); + proxyMap.set(target, proxy); + return proxy; + } + function isReactive(value) { + if (isReadonly(value)) { + return isReactive(value["__v_raw"]); + } + return !!(value && value["__v_isReactive"]); + } + function isReadonly(value) { + return !!(value && value["__v_isReadonly"]); + } + function isProxy(value) { + return isReactive(value) || isReadonly(value); + } + function toRaw(observed) { + return observed && toRaw(observed["__v_raw"]) || observed; + } + function markRaw(value) { + def(value, "__v_skip", true); + return value; + } + const convert = (val) => isObject$1(val) ? reactive(val) : val; + function isRef(r) { + return Boolean(r && r.__v_isRef === true); + } + function ref(value) { + return createRef(value); + } + class RefImpl { + constructor(_rawValue, _shallow) { + this._rawValue = _rawValue; + this._shallow = _shallow; + this.__v_isRef = true; + this._value = _shallow ? _rawValue : convert(_rawValue); + } + get value() { + track(toRaw(this), "get", "value"); + return this._value; + } + set value(newVal) { + if (hasChanged(toRaw(newVal), this._rawValue)) { + this._rawValue = newVal; + this._value = this._shallow ? newVal : convert(newVal); + trigger(toRaw(this), "set", "value", newVal); + } + } + } + function createRef(rawValue, shallow = false) { + if (isRef(rawValue)) { + return rawValue; + } + return new RefImpl(rawValue, shallow); + } + function unref(ref2) { + return isRef(ref2) ? ref2.value : ref2; + } + const shallowUnwrapHandlers = { + get: (target, key, receiver) => unref(Reflect.get(target, key, receiver)), + set: (target, key, value, receiver) => { + const oldValue = target[key]; + if (isRef(oldValue) && !isRef(value)) { + oldValue.value = value; + return true; + } else { + return Reflect.set(target, key, value, receiver); + } + } + }; + function proxyRefs(objectWithRefs) { + return isReactive(objectWithRefs) ? objectWithRefs : new Proxy(objectWithRefs, shallowUnwrapHandlers); + } + class ComputedRefImpl { + constructor(getter, _setter, isReadonly2) { + this._setter = _setter; + this._dirty = true; + this.__v_isRef = true; + this.effect = effect(getter, { + lazy: true, + scheduler: () => { + if (!this._dirty) { + this._dirty = true; + trigger(toRaw(this), "set", "value"); + } + } + }); + this["__v_isReadonly"] = isReadonly2; + } + get value() { + const self2 = toRaw(this); + if (self2._dirty) { + self2._value = this.effect(); + self2._dirty = false; + } + track(self2, "get", "value"); + return self2._value; + } + set value(newValue) { + this._setter(newValue); + } + } + function computed(getterOrOptions) { + let getter; + let setter; + if (isFunction(getterOrOptions)) { + getter = getterOrOptions; + setter = NOOP; + } else { + getter = getterOrOptions.get; + setter = getterOrOptions.set; + } + return new ComputedRefImpl(getter, setter, isFunction(getterOrOptions) || !getterOrOptions.set); + } + const stack = []; + function warn(msg, ...args) { + pauseTracking(); + const instance = stack.length ? stack[stack.length - 1].component : null; + const appWarnHandler = instance && instance.appContext.config.warnHandler; + const trace = getComponentTrace(); + if (appWarnHandler) { + callWithErrorHandling(appWarnHandler, instance, 11, [ + msg + args.join(""), + instance && instance.proxy, + trace.map(({ vnode }) => `at <${formatComponentName(instance, vnode.type)}>`).join("\n"), + trace + ]); + } else { + const warnArgs = [`[Vue warn]: ${msg}`, ...args]; + if (trace.length && true) { + warnArgs.push(` +`, ...formatTrace(trace)); + } + console.warn(...warnArgs); + } + resetTracking(); + } + function getComponentTrace() { + let currentVNode = stack[stack.length - 1]; + if (!currentVNode) { + return []; + } + const normalizedStack = []; + while (currentVNode) { + const last = normalizedStack[0]; + if (last && last.vnode === currentVNode) { + last.recurseCount++; + } else { + normalizedStack.push({ + vnode: currentVNode, + recurseCount: 0 + }); + } + const parentInstance = currentVNode.component && currentVNode.component.parent; + currentVNode = parentInstance && parentInstance.vnode; + } + return normalizedStack; + } + function formatTrace(trace) { + const logs = []; + trace.forEach((entry, i) => { + logs.push(...i === 0 ? [] : [` +`], ...formatTraceEntry(entry)); + }); + return logs; + } + function formatTraceEntry({ vnode, recurseCount }) { + const postfix = recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``; + const isRoot = vnode.component ? vnode.component.parent == null : false; + const open = ` at <${formatComponentName(vnode.component, vnode.type, isRoot)}`; + const close = `>` + postfix; + return vnode.props ? [open, ...formatProps(vnode.props), close] : [open + close]; + } + function formatProps(props2) { + const res = []; + const keys = Object.keys(props2); + keys.slice(0, 3).forEach((key) => { + res.push(...formatProp(key, props2[key])); + }); + if (keys.length > 3) { + res.push(` ...`); + } + return res; + } + function formatProp(key, value, raw) { + if (isString$1(value)) { + value = JSON.stringify(value); + return raw ? value : [`${key}=${value}`]; + } else if (typeof value === "number" || typeof value === "boolean" || value == null) { + return raw ? value : [`${key}=${value}`]; + } else if (isRef(value)) { + value = formatProp(key, toRaw(value.value), true); + return raw ? value : [`${key}=Ref<`, value, `>`]; + } else if (isFunction(value)) { + return [`${key}=fn${value.name ? `<${value.name}>` : ``}`]; + } else { + value = toRaw(value); + return raw ? value : [`${key}=`, value]; + } + } + function callWithErrorHandling(fn, instance, type, args) { + let res; + try { + res = args ? fn(...args) : fn(); + } catch (err) { + handleError(err, instance, type); + } + return res; + } + function callWithAsyncErrorHandling(fn, instance, type, args) { + if (isFunction(fn)) { + const res = callWithErrorHandling(fn, instance, type, args); + if (res && isPromise(res)) { + res.catch((err) => { + handleError(err, instance, type); + }); + } + return res; + } + const values = []; + for (let i = 0; i < fn.length; i++) { + values.push(callWithAsyncErrorHandling(fn[i], instance, type, args)); + } + return values; + } + function handleError(err, instance, type, throwInDev = true) { + const contextVNode = instance ? instance.vnode : null; + if (instance) { + let cur = instance.parent; + const exposedInstance = instance.proxy; + const errorInfo = type; + while (cur) { + const errorCapturedHooks = cur.ec; + if (errorCapturedHooks) { + for (let i = 0; i < errorCapturedHooks.length; i++) { + if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) { + return; + } + } + } + cur = cur.parent; + } + const appErrorHandler = instance.appContext.config.errorHandler; + if (appErrorHandler) { + callWithErrorHandling(appErrorHandler, null, 10, [err, exposedInstance, errorInfo]); + return; + } + } + logError(err, type, contextVNode, throwInDev); + } + function logError(err, type, contextVNode, throwInDev = true) { + { + console.error(err); + } + } + let isFlushing = false; + let isFlushPending = false; + const queue = []; + let flushIndex = 0; + const pendingPreFlushCbs = []; + let activePreFlushCbs = null; + let preFlushIndex = 0; + const pendingPostFlushCbs = []; + let activePostFlushCbs = null; + let postFlushIndex = 0; + const resolvedPromise = Promise.resolve(); + let currentFlushPromise = null; + let currentPreFlushParentJob = null; + const RECURSION_LIMIT = 100; + function nextTick(fn) { + const p2 = currentFlushPromise || resolvedPromise; + return fn ? p2.then(this ? fn.bind(this) : fn) : p2; + } + function findInsertionIndex(job) { + let start = flushIndex + 1; + let end = queue.length; + const jobId = getId(job); + while (start < end) { + const middle = start + end >>> 1; + const middleJobId = getId(queue[middle]); + middleJobId < jobId ? start = middle + 1 : end = middle; + } + return start; + } + function queueJob(job) { + if ((!queue.length || !queue.includes(job, isFlushing && job.allowRecurse ? flushIndex + 1 : flushIndex)) && job !== currentPreFlushParentJob) { + const pos = findInsertionIndex(job); + if (pos > -1) { + queue.splice(pos, 0, job); + } else { + queue.push(job); + } + queueFlush(); + } + } + function queueFlush() { + if (!isFlushing && !isFlushPending) { + isFlushPending = true; + currentFlushPromise = resolvedPromise.then(flushJobs); + } + } + function invalidateJob(job) { + const i = queue.indexOf(job); + if (i > flushIndex) { + queue.splice(i, 1); + } + } + function queueCb(cb, activeQueue, pendingQueue, index) { + if (!isArray(cb)) { + if (!activeQueue || !activeQueue.includes(cb, cb.allowRecurse ? index + 1 : index)) { + pendingQueue.push(cb); + } + } else { + pendingQueue.push(...cb); + } + queueFlush(); + } + function queuePreFlushCb(cb) { + queueCb(cb, activePreFlushCbs, pendingPreFlushCbs, preFlushIndex); + } + function queuePostFlushCb(cb) { + queueCb(cb, activePostFlushCbs, pendingPostFlushCbs, postFlushIndex); + } + function flushPreFlushCbs(seen, parentJob = null) { + if (pendingPreFlushCbs.length) { + currentPreFlushParentJob = parentJob; + activePreFlushCbs = [...new Set(pendingPreFlushCbs)]; + pendingPreFlushCbs.length = 0; + for (preFlushIndex = 0; preFlushIndex < activePreFlushCbs.length; preFlushIndex++) { + activePreFlushCbs[preFlushIndex](); + } + activePreFlushCbs = null; + preFlushIndex = 0; + currentPreFlushParentJob = null; + flushPreFlushCbs(seen, parentJob); + } + } + function flushPostFlushCbs(seen) { + if (pendingPostFlushCbs.length) { + const deduped = [...new Set(pendingPostFlushCbs)]; + pendingPostFlushCbs.length = 0; + if (activePostFlushCbs) { + activePostFlushCbs.push(...deduped); + return; + } + activePostFlushCbs = deduped; + activePostFlushCbs.sort((a, b) => getId(a) - getId(b)); + for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) { + activePostFlushCbs[postFlushIndex](); + } + activePostFlushCbs = null; + postFlushIndex = 0; + } + } + const getId = (job) => job.id == null ? Infinity : job.id; + function flushJobs(seen) { + isFlushPending = false; + isFlushing = true; + flushPreFlushCbs(seen); + queue.sort((a, b) => getId(a) - getId(b)); + try { + for (flushIndex = 0; flushIndex < queue.length; flushIndex++) { + const job = queue[flushIndex]; + if (job && job.active !== false) { + if (false) + ; + callWithErrorHandling(job, null, 14); + } + } + } finally { + flushIndex = 0; + queue.length = 0; + flushPostFlushCbs(); + isFlushing = false; + currentFlushPromise = null; + if (queue.length || pendingPreFlushCbs.length || pendingPostFlushCbs.length) { + flushJobs(seen); + } + } + } + function checkRecursiveUpdates(seen, fn) { + if (!seen.has(fn)) { + seen.set(fn, 1); + } else { + const count = seen.get(fn); + if (count > RECURSION_LIMIT) { + const instance = fn.ownerInstance; + const componentName = instance && getComponentName(instance.type); + warn(`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.`); + return true; + } else { + seen.set(fn, count + 1); + } + } + } + const globalCompatConfig = { + MODE: 2 + }; + function getCompatConfigForKey(key, instance) { + const instanceConfig = instance && instance.type.compatConfig; + if (instanceConfig && key in instanceConfig) { + return instanceConfig[key]; + } + return globalCompatConfig[key]; + } + function isCompatEnabled(key, instance, enableForBuiltIn = false) { + if (!enableForBuiltIn && instance && instance.type.__isBuiltIn) { + return false; + } + const rawMode = getCompatConfigForKey("MODE", instance) || 2; + const val = getCompatConfigForKey(key, instance); + const mode = isFunction(rawMode) ? rawMode(instance && instance.type) : rawMode; + if (mode === 2) { + return val !== false; + } else { + return val === true || val === "suppress-warning"; + } + } + function emit(instance, event, ...rawArgs) { + const props2 = instance.vnode.props || EMPTY_OBJ; + let args = rawArgs; + const isModelListener2 = event.startsWith("update:"); + const modelArg = isModelListener2 && event.slice(7); + if (modelArg && modelArg in props2) { + const modifiersKey = `${modelArg === "modelValue" ? "model" : modelArg}Modifiers`; + const { number, trim } = props2[modifiersKey] || EMPTY_OBJ; + if (trim) { + args = rawArgs.map((a) => a.trim()); + } else if (number) { + args = rawArgs.map(toNumber); + } + } + let handlerName; + let handler = props2[handlerName = toHandlerKey(event)] || props2[handlerName = toHandlerKey(camelize(event))]; + if (!handler && isModelListener2) { + handler = props2[handlerName = toHandlerKey(hyphenate(event))]; + } + if (handler) { + callWithAsyncErrorHandling(handler, instance, 6, args); + } + const onceHandler = props2[handlerName + `Once`]; + if (onceHandler) { + if (!instance.emitted) { + instance.emitted = {}; + } else if (instance.emitted[handlerName]) { + return; + } + instance.emitted[handlerName] = true; + callWithAsyncErrorHandling(onceHandler, instance, 6, args); + } + } + function normalizeEmitsOptions(comp, appContext, asMixin = false) { + const cache = appContext.emitsCache; + const cached = cache.get(comp); + if (cached !== void 0) { + return cached; + } + const raw = comp.emits; + let normalized = {}; + let hasExtends = false; + if (!isFunction(comp)) { + const extendEmits = (raw2) => { + const normalizedFromExtend = normalizeEmitsOptions(raw2, appContext, true); + if (normalizedFromExtend) { + hasExtends = true; + extend$1(normalized, normalizedFromExtend); + } + }; + if (!asMixin && appContext.mixins.length) { + appContext.mixins.forEach(extendEmits); + } + if (comp.extends) { + extendEmits(comp.extends); + } + if (comp.mixins) { + comp.mixins.forEach(extendEmits); + } + } + if (!raw && !hasExtends) { + cache.set(comp, null); + return null; + } + if (isArray(raw)) { + raw.forEach((key) => normalized[key] = null); + } else { + extend$1(normalized, raw); + } + cache.set(comp, normalized); + return normalized; + } + function isEmitListener(options, key) { + if (!options || !isOn(key)) { + return false; + } + key = key.slice(2).replace(/Once$/, ""); + return hasOwn$1(options, key[0].toLowerCase() + key.slice(1)) || hasOwn$1(options, hyphenate(key)) || hasOwn$1(options, key); + } + let currentRenderingInstance = null; + let currentScopeId = null; + function setCurrentRenderingInstance(instance) { + const prev = currentRenderingInstance; + currentRenderingInstance = instance; + currentScopeId = instance && instance.type.__scopeId || null; + return prev; + } + function withCtx(fn, ctx = currentRenderingInstance, isNonScopedSlot) { + if (!ctx) + return fn; + if (fn._n) { + return fn; + } + const renderFnWithContext = (...args) => { + if (renderFnWithContext._d) { + setBlockTracking(-1); + } + const prevInstance = setCurrentRenderingInstance(ctx); + const res = fn(...args); + setCurrentRenderingInstance(prevInstance); + if (renderFnWithContext._d) { + setBlockTracking(1); + } + return res; + }; + renderFnWithContext._n = true; + renderFnWithContext._c = true; + renderFnWithContext._d = true; + return renderFnWithContext; + } + let accessedAttrs = false; + function markAttrsAccessed() { + accessedAttrs = true; + } + function renderComponentRoot(instance) { + const { type: Component, vnode, proxy, withProxy, props: props2, propsOptions: [propsOptions], slots, attrs, emit: emit2, render, renderCache, data, setupState, ctx, inheritAttrs } = instance; + let result; + const prev = setCurrentRenderingInstance(instance); + try { + let fallthroughAttrs; + if (vnode.shapeFlag & 4) { + const proxyToUse = withProxy || proxy; + result = normalizeVNode(render.call(proxyToUse, proxyToUse, renderCache, props2, setupState, data, ctx)); + fallthroughAttrs = attrs; + } else { + const render2 = Component; + if (false) + ; + result = normalizeVNode(render2.length > 1 ? render2(props2, false ? { + get attrs() { + markAttrsAccessed(); + return attrs; + }, + slots, + emit: emit2 + } : { attrs, slots, emit: emit2 }) : render2(props2, null)); + fallthroughAttrs = Component.props ? attrs : getFunctionalFallthrough(attrs); + } + let root = result; + let setRoot = void 0; + if (false) + ; + if (fallthroughAttrs && inheritAttrs !== false) { + const keys = Object.keys(fallthroughAttrs); + const { shapeFlag } = root; + if (keys.length) { + if (shapeFlag & 1 || shapeFlag & 6) { + if (propsOptions && keys.some(isModelListener)) { + fallthroughAttrs = filterModelListeners(fallthroughAttrs, propsOptions); + } + root = cloneVNode(root, fallthroughAttrs); + } else if (false) + ; + } + } + if (false) + ; + if (vnode.dirs) { + if (false) + ; + root.dirs = root.dirs ? root.dirs.concat(vnode.dirs) : vnode.dirs; + } + if (vnode.transition) { + if (false) + ; + root.transition = vnode.transition; + } + if (false) + ; + else { + result = root; + } + } catch (err) { + handleError(err, instance, 1); + result = createVNode(Comment$1); + } + setCurrentRenderingInstance(prev); + return result; + } + const getChildRoot = (vnode) => { + const rawChildren = vnode.children; + const dynamicChildren = vnode.dynamicChildren; + const childRoot = filterSingleRoot(rawChildren); + if (!childRoot) { + return [vnode, void 0]; + } + const index = rawChildren.indexOf(childRoot); + const dynamicIndex = dynamicChildren ? dynamicChildren.indexOf(childRoot) : -1; + const setRoot = (updatedRoot) => { + rawChildren[index] = updatedRoot; + if (dynamicChildren) { + if (dynamicIndex > -1) { + dynamicChildren[dynamicIndex] = updatedRoot; + } else if (updatedRoot.patchFlag > 0) { + vnode.dynamicChildren = [...dynamicChildren, updatedRoot]; + } + } + }; + return [normalizeVNode(childRoot), setRoot]; + }; + function filterSingleRoot(children) { + let singleRoot; + for (let i = 0; i < children.length; i++) { + const child = children[i]; + if (isVNode(child)) { + if (child.type !== Comment$1 || child.children === "v-if") { + if (singleRoot) { + return; + } else { + singleRoot = child; + } + } + } else { + return; + } + } + return singleRoot; + } + const getFunctionalFallthrough = (attrs) => { + let res; + for (const key in attrs) { + if (key === "class" || key === "style" || isOn(key)) { + (res || (res = {}))[key] = attrs[key]; + } + } + return res; + }; + const filterModelListeners = (attrs, props2) => { + const res = {}; + for (const key in attrs) { + if (!isModelListener(key) || !(key.slice(9) in props2)) { + res[key] = attrs[key]; + } + } + return res; + }; + const isElementRoot = (vnode) => { + return vnode.shapeFlag & 6 || vnode.shapeFlag & 1 || vnode.type === Comment$1; + }; + function shouldUpdateComponent(prevVNode, nextVNode, optimized) { + const { props: prevProps, children: prevChildren, component } = prevVNode; + const { props: nextProps, children: nextChildren, patchFlag } = nextVNode; + const emits = component.emitsOptions; + if (nextVNode.dirs || nextVNode.transition) { + return true; + } + if (optimized && patchFlag >= 0) { + if (patchFlag & 1024) { + return true; + } + if (patchFlag & 16) { + if (!prevProps) { + return !!nextProps; + } + return hasPropsChanged(prevProps, nextProps, emits); + } else if (patchFlag & 8) { + const dynamicProps = nextVNode.dynamicProps; + for (let i = 0; i < dynamicProps.length; i++) { + const key = dynamicProps[i]; + if (nextProps[key] !== prevProps[key] && !isEmitListener(emits, key)) { + return true; + } + } + } + } else { + if (prevChildren || nextChildren) { + if (!nextChildren || !nextChildren.$stable) { + return true; + } + } + if (prevProps === nextProps) { + return false; + } + if (!prevProps) { + return !!nextProps; + } + if (!nextProps) { + return true; + } + return hasPropsChanged(prevProps, nextProps, emits); + } + return false; + } + function hasPropsChanged(prevProps, nextProps, emitsOptions) { + const nextKeys = Object.keys(nextProps); + if (nextKeys.length !== Object.keys(prevProps).length) { + return true; + } + for (let i = 0; i < nextKeys.length; i++) { + const key = nextKeys[i]; + if (nextProps[key] !== prevProps[key] && !isEmitListener(emitsOptions, key)) { + return true; + } + } + return false; + } + function updateHOCHostEl({ vnode, parent }, el) { + while (parent && parent.subTree === vnode) { + (vnode = parent.vnode).el = el; + parent = parent.parent; + } + } + 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(fn); + } + } + function provide(key, value) { + if (!currentInstance) + ; + else { + let provides = currentInstance.provides; + const parentProvides = currentInstance.parent && currentInstance.parent.provides; + if (parentProvides === provides) { + provides = currentInstance.provides = Object.create(parentProvides); + } + provides[key] = value; + } + } + function inject(key, defaultValue, treatDefaultAsFactory = false) { + const instance = currentInstance || currentRenderingInstance; + if (instance) { + const provides = instance.parent == null ? instance.vnode.appContext && instance.vnode.appContext.provides : instance.parent.provides; + if (provides && key in provides) { + return provides[key]; + } else if (arguments.length > 1) { + return treatDefaultAsFactory && isFunction(defaultValue) ? defaultValue.call(instance.proxy) : defaultValue; + } else + ; + } + } + const INITIAL_WATCHER_VALUE = {}; + function watch(source, cb, options) { + return doWatch(source, cb, options); + } + function doWatch(source, cb, { immediate, deep, flush, onTrack, onTrigger } = EMPTY_OBJ, instance = currentInstance) { + let getter; + let forceTrigger = false; + let isMultiSource = false; + if (isRef(source)) { + getter = () => source.value; + forceTrigger = !!source._shallow; + } else if (isReactive(source)) { + getter = () => source; + deep = true; + } else if (isArray(source)) { + isMultiSource = true; + forceTrigger = source.some(isReactive); + getter = () => source.map((s) => { + if (isRef(s)) { + return s.value; + } else if (isReactive(s)) { + return traverse(s); + } else if (isFunction(s)) { + return callWithErrorHandling(s, instance, 2); + } else + ; + }); + } else if (isFunction(source)) { + if (cb) { + getter = () => callWithErrorHandling(source, instance, 2); + } else { + getter = () => { + if (instance && instance.isUnmounted) { + return; + } + if (cleanup2) { + cleanup2(); + } + return callWithAsyncErrorHandling(source, instance, 3, [onInvalidate]); + }; + } + } else { + getter = NOOP; + } + if (cb && deep) { + const baseGetter = getter; + getter = () => traverse(baseGetter()); + } + let cleanup2; + let onInvalidate = (fn) => { + cleanup2 = runner.options.onStop = () => { + callWithErrorHandling(fn, instance, 4); + }; + }; + let oldValue = isMultiSource ? [] : INITIAL_WATCHER_VALUE; + const job = () => { + if (!runner.active) { + return; + } + if (cb) { + const newValue = runner(); + if (deep || forceTrigger || (isMultiSource ? newValue.some((v, i) => hasChanged(v, oldValue[i])) : hasChanged(newValue, oldValue)) || false) { + if (cleanup2) { + cleanup2(); + } + callWithAsyncErrorHandling(cb, instance, 3, [ + newValue, + oldValue === INITIAL_WATCHER_VALUE ? void 0 : oldValue, + onInvalidate + ]); + oldValue = newValue; + } + } else { + runner(); + } + }; + job.allowRecurse = !!cb; + let scheduler; + if (flush === "sync") { + scheduler = job; + } else if (flush === "post") { + scheduler = () => queuePostRenderEffect(job, instance && instance.suspense); + } else { + scheduler = () => { + if (!instance || instance.isMounted) { + queuePreFlushCb(job); + } else { + job(); + } + }; + } + const runner = effect(getter, { + lazy: true, + onTrack, + onTrigger, + scheduler + }); + recordInstanceBoundEffect(runner, instance); + if (cb) { + if (immediate) { + job(); + } else { + oldValue = runner(); + } + } else if (flush === "post") { + queuePostRenderEffect(runner, instance && instance.suspense); + } else { + runner(); + } + return () => { + stop(runner); + if (instance) { + remove(instance.effects, runner); + } + }; + } + function instanceWatch(source, value, options) { + const publicThis = this.proxy; + const getter = isString$1(source) ? source.includes(".") ? createPathGetter(publicThis, source) : () => publicThis[source] : source.bind(publicThis, publicThis); + let cb; + if (isFunction(value)) { + cb = value; + } else { + cb = value.handler; + options = value; + } + return doWatch(getter, cb.bind(publicThis), options, this); + } + function createPathGetter(ctx, path) { + const segments = path.split("."); + return () => { + let cur = ctx; + for (let i = 0; i < segments.length && cur; i++) { + cur = cur[segments[i]]; + } + return cur; + }; + } + function traverse(value, seen = new Set()) { + if (!isObject$1(value) || seen.has(value) || value["__v_skip"]) { + return value; + } + seen.add(value); + if (isRef(value)) { + traverse(value.value, seen); + } else if (isArray(value)) { + for (let i = 0; i < value.length; i++) { + traverse(value[i], seen); + } + } else if (isSet(value) || isMap(value)) { + value.forEach((v) => { + traverse(v, seen); + }); + } else if (isPlainObject$1(value)) { + for (const key in value) { + traverse(value[key], seen); + } + } + return value; + } + function defineComponent(options) { + return isFunction(options) ? { setup: options, name: options.name } : options; + } + const isAsyncWrapper = (i) => !!i.type.__asyncLoader; + const isKeepAlive = (vnode) => vnode.type.__isKeepAlive; + function onActivated(hook, target) { + registerKeepAliveHook(hook, "a", target); + } + function onDeactivated(hook, target) { + registerKeepAliveHook(hook, "da", target); + } + function registerKeepAliveHook(hook, type, target = currentInstance) { + const wrappedHook = hook.__wdc || (hook.__wdc = () => { + let current = target; + while (current) { + if (current.isDeactivated) { + return; + } + current = current.parent; + } + hook(); + }); + injectHook(type, wrappedHook, target); + if (target) { + let current = target.parent; + while (current && current.parent) { + if (isKeepAlive(current.parent.vnode)) { + injectToKeepAliveRoot(wrappedHook, type, target, current); + } + current = current.parent; + } + } + } + function injectToKeepAliveRoot(hook, type, target, keepAliveRoot) { + const injected = injectHook(type, hook, keepAliveRoot, true); + onUnmounted(() => { + remove(keepAliveRoot[type], injected); + }, target); + } + function injectHook(type, hook, target = currentInstance, prepend = false) { + if (target) { + const hooks = target[type] || (target[type] = []); + const wrappedHook = hook.__weh || (hook.__weh = (...args) => { + if (target.isUnmounted) { + return; + } + pauseTracking(); + setCurrentInstance(target); + const res = callWithAsyncErrorHandling(hook, target, type, args); + setCurrentInstance(null); + resetTracking(); + return res; + }); + if (prepend) { + hooks.unshift(wrappedHook); + } else { + hooks.push(wrappedHook); + } + return wrappedHook; + } + } + const createHook = (lifecycle) => (hook, target = currentInstance) => (!isInSSRComponentSetup || lifecycle === "sp") && injectHook(lifecycle, hook, 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"); + function onErrorCaptured(hook, target = currentInstance) { + injectHook("ec", hook, target); + } + let shouldCacheAccess = true; + function applyOptions(instance) { + const options = resolveMergedOptions(instance); + const publicThis = instance.proxy; + const ctx = instance.ctx; + shouldCacheAccess = false; + if (options.beforeCreate) { + callHook(options.beforeCreate, instance, "bc"); + } + const { + data: dataOptions, + computed: computedOptions, + methods, + watch: watchOptions, + provide: provideOptions, + inject: injectOptions, + created, + beforeMount, + mounted, + beforeUpdate, + updated, + activated, + deactivated, + beforeDestroy, + beforeUnmount, + destroyed, + unmounted, + render, + renderTracked, + renderTriggered, + errorCaptured, + serverPrefetch, + expose, + inheritAttrs, + components, + directives, + filters + } = options; + const checkDuplicateProperties = null; + if (injectOptions) { + resolveInjections(injectOptions, ctx, checkDuplicateProperties); + } + if (methods) { + for (const key in methods) { + const methodHandler = methods[key]; + if (isFunction(methodHandler)) { + { + ctx[key] = methodHandler.bind(publicThis); + } + } + } + } + if (dataOptions) { + const data = dataOptions.call(publicThis, publicThis); + if (!isObject$1(data)) + ; + else { + instance.data = reactive(data); + } + } + shouldCacheAccess = true; + if (computedOptions) { + for (const key in computedOptions) { + const opt = computedOptions[key]; + const get2 = isFunction(opt) ? opt.bind(publicThis, publicThis) : isFunction(opt.get) ? opt.get.bind(publicThis, publicThis) : NOOP; + const set2 = !isFunction(opt) && isFunction(opt.set) ? opt.set.bind(publicThis) : NOOP; + const c = computed$1({ + get: get2, + set: set2 + }); + Object.defineProperty(ctx, key, { + enumerable: true, + configurable: true, + get: () => c.value, + set: (v) => c.value = v + }); + } + } + if (watchOptions) { + for (const key in watchOptions) { + createWatcher(watchOptions[key], ctx, publicThis, key); + } + } + if (provideOptions) { + const provides = isFunction(provideOptions) ? provideOptions.call(publicThis) : provideOptions; + Reflect.ownKeys(provides).forEach((key) => { + provide(key, provides[key]); + }); + } + if (created) { + callHook(created, instance, "c"); + } + function registerLifecycleHook(register, hook) { + if (isArray(hook)) { + hook.forEach((_hook) => register(_hook.bind(publicThis))); + } else if (hook) { + register(hook.bind(publicThis)); + } + } + registerLifecycleHook(onBeforeMount, beforeMount); + registerLifecycleHook(onMounted, mounted); + registerLifecycleHook(onBeforeUpdate, beforeUpdate); + registerLifecycleHook(onUpdated, updated); + registerLifecycleHook(onActivated, activated); + registerLifecycleHook(onDeactivated, deactivated); + registerLifecycleHook(onErrorCaptured, errorCaptured); + registerLifecycleHook(onRenderTracked, renderTracked); + registerLifecycleHook(onRenderTriggered, renderTriggered); + registerLifecycleHook(onBeforeUnmount, beforeUnmount); + registerLifecycleHook(onUnmounted, unmounted); + registerLifecycleHook(onServerPrefetch, serverPrefetch); + if (isArray(expose)) { + if (expose.length) { + const exposed = instance.exposed || (instance.exposed = {}); + expose.forEach((key) => { + Object.defineProperty(exposed, key, { + get: () => publicThis[key], + set: (val) => publicThis[key] = val + }); + }); + } else if (!instance.exposed) { + instance.exposed = {}; + } + } + if (render && instance.render === NOOP) { + instance.render = render; + } + if (inheritAttrs != null) { + instance.inheritAttrs = inheritAttrs; + } + if (components) + instance.components = components; + if (directives) + instance.directives = directives; + } + function resolveInjections(injectOptions, ctx, checkDuplicateProperties = NOOP) { + if (isArray(injectOptions)) { + injectOptions = normalizeInject(injectOptions); + } + for (const key in injectOptions) { + const opt = injectOptions[key]; + if (isObject$1(opt)) { + if ("default" in opt) { + ctx[key] = inject(opt.from || key, opt.default, true); + } else { + ctx[key] = inject(opt.from || key); + } + } else { + ctx[key] = inject(opt); + } + } + } + function callHook(hook, instance, type) { + callWithAsyncErrorHandling(isArray(hook) ? hook.map((h2) => h2.bind(instance.proxy)) : hook.bind(instance.proxy), instance, type); + } + function createWatcher(raw, ctx, publicThis, key) { + const getter = key.includes(".") ? createPathGetter(publicThis, key) : () => publicThis[key]; + if (isString$1(raw)) { + const handler = ctx[raw]; + if (isFunction(handler)) { + watch(getter, handler); + } + } else if (isFunction(raw)) { + watch(getter, raw.bind(publicThis)); + } else if (isObject$1(raw)) { + if (isArray(raw)) { + raw.forEach((r) => createWatcher(r, ctx, publicThis, key)); + } else { + const handler = isFunction(raw.handler) ? raw.handler.bind(publicThis) : ctx[raw.handler]; + if (isFunction(handler)) { + watch(getter, handler, raw); + } + } + } else + ; + } + 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); + } + 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") + ; + 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: mergeObjectOptions, + emits: mergeObjectOptions, + methods: mergeObjectOptions, + computed: mergeObjectOptions, + beforeCreate: mergeAsArray, + created: mergeAsArray, + beforeMount: mergeAsArray, + mounted: mergeAsArray, + beforeUpdate: mergeAsArray, + updated: mergeAsArray, + beforeDestroy: mergeAsArray, + destroyed: mergeAsArray, + activated: mergeAsArray, + deactivated: mergeAsArray, + errorCaptured: mergeAsArray, + serverPrefetch: mergeAsArray, + components: mergeObjectOptions, + directives: mergeObjectOptions, + watch: mergeWatchOptions, + provide: mergeDataFn, + inject: mergeInject + }; + function mergeDataFn(to, from) { + if (!from) { + return to; + } + if (!to) { + return from; + } + return function mergedDataFn() { + return extend$1(isFunction(to) ? to.call(this, this) : to, isFunction(from) ? from.call(this, this) : from); + }; + } + function mergeInject(to, from) { + return mergeObjectOptions(normalizeInject(to), normalizeInject(from)); + } + function normalizeInject(raw) { + if (isArray(raw)) { + const res = {}; + for (let i = 0; i < raw.length; i++) { + res[raw[i]] = raw[i]; + } + return res; + } + return raw; + } + function mergeAsArray(to, from) { + return to ? [...new Set([].concat(to, from))] : from; + } + function mergeObjectOptions(to, from) { + return to ? extend$1(extend$1(Object.create(null), to), from) : from; + } + function mergeWatchOptions(to, from) { + if (!to) + return from; + if (!from) + return to; + const merged = extend$1(Object.create(null), to); + for (const key in from) { + merged[key] = mergeAsArray(to[key], from[key]); + } + return merged; + } + function initProps(instance, rawProps, isStateful, isSSR = false) { + const props2 = {}; + const attrs = {}; + def(attrs, InternalObjectKey, 1); + instance.propsDefaults = Object.create(null); + setFullProps(instance, rawProps, props2, attrs); + for (const key in instance.propsOptions[0]) { + if (!(key in props2)) { + props2[key] = void 0; + } + } + if (isStateful) { + instance.props = isSSR ? props2 : shallowReactive(props2); + } else { + if (!instance.type.props) { + instance.props = attrs; + } else { + instance.props = props2; + } + } + instance.attrs = attrs; + } + function updateProps(instance, rawProps, rawPrevProps, optimized) { + const { props: props2, attrs, vnode: { patchFlag } } = instance; + const rawCurrentProps = toRaw(props2); + const [options] = instance.propsOptions; + let hasAttrsChanged = false; + if ((optimized || patchFlag > 0) && !(patchFlag & 16)) { + if (patchFlag & 8) { + const propsToUpdate = instance.vnode.dynamicProps; + for (let i = 0; i < propsToUpdate.length; i++) { + let key = propsToUpdate[i]; + const value = rawProps[key]; + if (options) { + if (hasOwn$1(attrs, key)) { + if (value !== attrs[key]) { + attrs[key] = value; + hasAttrsChanged = true; + } + } else { + const camelizedKey = camelize(key); + props2[camelizedKey] = resolvePropValue(options, rawCurrentProps, camelizedKey, value, instance, false); + } + } else { + if (value !== attrs[key]) { + attrs[key] = value; + hasAttrsChanged = true; + } + } + } + } + } else { + if (setFullProps(instance, rawProps, props2, attrs)) { + hasAttrsChanged = true; + } + let kebabKey; + for (const key in rawCurrentProps) { + if (!rawProps || !hasOwn$1(rawProps, key) && ((kebabKey = hyphenate(key)) === key || !hasOwn$1(rawProps, kebabKey))) { + if (options) { + if (rawPrevProps && (rawPrevProps[key] !== void 0 || rawPrevProps[kebabKey] !== void 0)) { + props2[key] = resolvePropValue(options, rawCurrentProps, key, void 0, instance, true); + } + } else { + delete props2[key]; + } + } + } + if (attrs !== rawCurrentProps) { + for (const key in attrs) { + if (!rawProps || !hasOwn$1(rawProps, key)) { + delete attrs[key]; + hasAttrsChanged = true; + } + } + } + } + if (hasAttrsChanged) { + trigger(instance, "set", "$attrs"); + } + } + function setFullProps(instance, rawProps, props2, attrs) { + const [options, needCastKeys] = instance.propsOptions; + let hasAttrsChanged = false; + let rawCastValues; + if (rawProps) { + for (let key in rawProps) { + if (isReservedProp(key)) { + continue; + } + const value = rawProps[key]; + let camelKey; + if (options && hasOwn$1(options, camelKey = camelize(key))) { + if (!needCastKeys || !needCastKeys.includes(camelKey)) { + props2[camelKey] = value; + } else { + (rawCastValues || (rawCastValues = {}))[camelKey] = value; + } + } else if (!isEmitListener(instance.emitsOptions, key)) { + if (value !== attrs[key]) { + attrs[key] = value; + hasAttrsChanged = true; + } + } + } + } + if (needCastKeys) { + const rawCurrentProps = toRaw(props2); + const castValues = rawCastValues || EMPTY_OBJ; + for (let i = 0; i < needCastKeys.length; i++) { + const key = needCastKeys[i]; + props2[key] = resolvePropValue(options, rawCurrentProps, key, castValues[key], instance, !hasOwn$1(castValues, key)); + } + } + return hasAttrsChanged; + } + function resolvePropValue(options, props2, key, value, instance, isAbsent) { + const opt = options[key]; + if (opt != null) { + const hasDefault = hasOwn$1(opt, "default"); + if (hasDefault && value === void 0) { + const defaultValue = opt.default; + if (opt.type !== Function && isFunction(defaultValue)) { + const { propsDefaults } = instance; + if (key in propsDefaults) { + value = propsDefaults[key]; + } else { + setCurrentInstance(instance); + value = propsDefaults[key] = defaultValue.call(null, props2); + setCurrentInstance(null); + } + } else { + value = defaultValue; + } + } + if (opt[0]) { + if (isAbsent && !hasDefault) { + value = false; + } else if (opt[1] && (value === "" || value === hyphenate(key))) { + value = true; + } + } + } + return value; + } + function normalizePropsOptions(comp, appContext, asMixin = false) { + const cache = appContext.propsCache; + const cached = cache.get(comp); + if (cached) { + return cached; + } + const raw = comp.props; + const normalized = {}; + const needCastKeys = []; + let hasExtends = false; + if (!isFunction(comp)) { + const extendProps = (raw2) => { + hasExtends = true; + const [props2, keys] = normalizePropsOptions(raw2, appContext, true); + extend$1(normalized, props2); + if (keys) + needCastKeys.push(...keys); + }; + if (!asMixin && appContext.mixins.length) { + appContext.mixins.forEach(extendProps); + } + if (comp.extends) { + extendProps(comp.extends); + } + if (comp.mixins) { + comp.mixins.forEach(extendProps); + } + } + if (!raw && !hasExtends) { + cache.set(comp, EMPTY_ARR); + return EMPTY_ARR; + } + if (isArray(raw)) { + for (let i = 0; i < raw.length; i++) { + const normalizedKey = camelize(raw[i]); + if (validatePropName(normalizedKey)) { + normalized[normalizedKey] = EMPTY_OBJ; + } + } + } else if (raw) { + for (const key in raw) { + const normalizedKey = camelize(key); + if (validatePropName(normalizedKey)) { + const opt = raw[key]; + const prop = normalized[normalizedKey] = isArray(opt) || isFunction(opt) ? { type: opt } : opt; + if (prop) { + const booleanIndex = getTypeIndex(Boolean, prop.type); + const stringIndex = getTypeIndex(String, prop.type); + prop[0] = booleanIndex > -1; + prop[1] = stringIndex < 0 || booleanIndex < stringIndex; + if (booleanIndex > -1 || hasOwn$1(prop, "default")) { + needCastKeys.push(normalizedKey); + } + } + } + } + } + const res = [normalized, needCastKeys]; + cache.set(comp, res); + return res; + } + function validatePropName(key) { + if (key[0] !== "$") { + return true; + } + return false; + } + function getType(ctor) { + const match = ctor && ctor.toString().match(/^\s*function (\w+)/); + return match ? match[1] : ""; + } + function isSameType(a, b) { + return getType(a) === getType(b); + } + function getTypeIndex(type, expectedTypes) { + if (isArray(expectedTypes)) { + return expectedTypes.findIndex((t) => isSameType(t, type)); + } else if (isFunction(expectedTypes)) { + return isSameType(expectedTypes, type) ? 0 : -1; + } + return -1; + } + const isInternalKey = (key) => key[0] === "_" || key === "$stable"; + const normalizeSlotValue = (value) => isArray(value) ? value.map(normalizeVNode) : [normalizeVNode(value)]; + const normalizeSlot = (key, rawSlot, ctx) => { + const normalized = withCtx((props2) => { + return normalizeSlotValue(rawSlot(props2)); + }, ctx); + normalized._c = false; + return normalized; + }; + const normalizeObjectSlots = (rawSlots, slots, instance) => { + const ctx = rawSlots._ctx; + for (const key in rawSlots) { + if (isInternalKey(key)) + continue; + const value = rawSlots[key]; + if (isFunction(value)) { + slots[key] = normalizeSlot(key, value, ctx); + } else if (value != null) { + const normalized = normalizeSlotValue(value); + slots[key] = () => normalized; + } + } + }; + const normalizeVNodeSlots = (instance, children) => { + const normalized = normalizeSlotValue(children); + instance.slots.default = () => normalized; + }; + const initSlots = (instance, children) => { + if (instance.vnode.shapeFlag & 32) { + const type = children._; + if (type) { + instance.slots = toRaw(children); + def(children, "_", type); + } else { + normalizeObjectSlots(children, instance.slots = {}); + } + } else { + instance.slots = {}; + if (children) { + normalizeVNodeSlots(instance, children); + } + } + def(instance.slots, InternalObjectKey, 1); + }; + const updateSlots = (instance, children, optimized) => { + const { vnode, slots } = instance; + let needDeletionCheck = true; + let deletionComparisonTarget = EMPTY_OBJ; + if (vnode.shapeFlag & 32) { + const type = children._; + if (type) { + if (optimized && type === 1) { + needDeletionCheck = false; + } else { + extend$1(slots, children); + if (!optimized && type === 1) { + delete slots._; + } + } + } else { + needDeletionCheck = !children.$stable; + normalizeObjectSlots(children, slots); + } + deletionComparisonTarget = children; + } else if (children) { + normalizeVNodeSlots(instance, children); + deletionComparisonTarget = { default: 1 }; + } + if (needDeletionCheck) { + for (const key in slots) { + if (!isInternalKey(key) && !(key in deletionComparisonTarget)) { + delete slots[key]; + } + } + } + }; + function invokeDirectiveHook(vnode, prevVNode, instance, name) { + const bindings = vnode.dirs; + const oldBindings = prevVNode && prevVNode.dirs; + for (let i = 0; i < bindings.length; i++) { + const binding = bindings[i]; + if (oldBindings) { + binding.oldValue = oldBindings[i].value; + } + let hook = binding.dir[name]; + if (hook) { + pauseTracking(); + callWithAsyncErrorHandling(hook, instance, 8, [ + vnode.el, + binding, + vnode, + prevVNode + ]); + resetTracking(); + } + } + } + function createAppContext() { + return { + app: null, + config: { + isNativeTag: NO, + performance: false, + globalProperties: {}, + optionMergeStrategies: {}, + errorHandler: void 0, + warnHandler: void 0, + compilerOptions: {} + }, + mixins: [], + components: {}, + directives: {}, + provides: Object.create(null), + optionsCache: new WeakMap(), + propsCache: new WeakMap(), + emitsCache: new WeakMap() + }; + } + let uid$1 = 0; + function createAppAPI(render, hydrate) { + return function createApp2(rootComponent, rootProps = null) { + if (rootProps != null && !isObject$1(rootProps)) { + rootProps = null; + } + const context = createAppContext(); + const installedPlugins = new Set(); + let isMounted = false; + const app = context.app = { + _uid: uid$1++, + _component: rootComponent, + _props: rootProps, + _container: null, + _context: context, + _instance: null, + version, + get config() { + return context.config; + }, + set config(v) { + }, + use(plugin, ...options) { + if (installedPlugins.has(plugin)) + ; + else if (plugin && isFunction(plugin.install)) { + installedPlugins.add(plugin); + plugin.install(app, ...options); + } else if (isFunction(plugin)) { + installedPlugins.add(plugin); + plugin(app, ...options); + } else + ; + return app; + }, + mixin(mixin) { + { + if (!context.mixins.includes(mixin)) { + context.mixins.push(mixin); + } + } + return app; + }, + component(name, component) { + if (!component) { + return context.components[name]; + } + context.components[name] = component; + return app; + }, + directive(name, directive) { + if (!directive) { + return context.directives[name]; + } + context.directives[name] = directive; + return app; + }, + mount(rootContainer, isHydrate, isSVG) { + if (!isMounted) { + const vnode = createVNode(rootComponent, rootProps); + vnode.appContext = context; + if (isHydrate && hydrate) { + hydrate(vnode, rootContainer); + } else { + render(vnode, rootContainer, isSVG); + } + isMounted = true; + app._container = rootContainer; + rootContainer.__vue_app__ = app; + return vnode.component.proxy; + } + }, + unmount() { + if (isMounted) { + render(null, app._container); + delete app._container.__vue_app__; + } + }, + provide(key, value) { + context.provides[key] = value; + return app; + } + }; + return app; + }; + } + const prodEffectOptions = { + scheduler: queueJob, + allowRecurse: true + }; + const queuePostRenderEffect = queueEffectWithSuspense; + const setRef = (rawRef, oldRawRef, parentSuspense, vnode, isUnmount = false) => { + if (isArray(rawRef)) { + rawRef.forEach((r, i) => setRef(r, oldRawRef && (isArray(oldRawRef) ? oldRawRef[i] : oldRawRef), parentSuspense, vnode, isUnmount)); + return; + } + if (isAsyncWrapper(vnode) && !isUnmount) { + return; + } + const refValue = vnode.shapeFlag & 4 ? getExposeProxy(vnode.component) || vnode.component.proxy : vnode.el; + const value = isUnmount ? null : refValue; + const { i: owner, r: ref2 } = rawRef; + const oldRef = oldRawRef && oldRawRef.r; + const refs = owner.refs === EMPTY_OBJ ? owner.refs = {} : owner.refs; + const setupState = owner.setupState; + if (oldRef != null && oldRef !== ref2) { + if (isString$1(oldRef)) { + refs[oldRef] = null; + if (hasOwn$1(setupState, oldRef)) { + setupState[oldRef] = null; + } + } else if (isRef(oldRef)) { + oldRef.value = null; + } + } + if (isString$1(ref2)) { + const doSet = () => { + { + refs[ref2] = value; + } + if (hasOwn$1(setupState, ref2)) { + setupState[ref2] = value; + } + }; + if (value) { + doSet.id = -1; + queuePostRenderEffect(doSet, parentSuspense); + } else { + doSet(); + } + } else if (isRef(ref2)) { + const doSet = () => { + ref2.value = value; + }; + if (value) { + doSet.id = -1; + queuePostRenderEffect(doSet, parentSuspense); + } else { + doSet(); + } + } else if (isFunction(ref2)) { + callWithErrorHandling(ref2, owner, 12, [value, refs]); + } else + ; + }; + function createRenderer(options) { + return baseCreateRenderer(options); + } + function baseCreateRenderer(options, createHydrationFns) { + const { insert: hostInsert, remove: hostRemove, patchProp: hostPatchProp, forcePatchProp: hostForcePatchProp, createElement: hostCreateElement, createText: hostCreateText, createComment: hostCreateComment, setText: hostSetText, setElementText: hostSetElementText, parentNode: hostParentNode, nextSibling: hostNextSibling, setScopeId: hostSetScopeId = NOOP, cloneNode: hostCloneNode, insertStaticContent: hostInsertStaticContent } = options; + const patch = (n1, n2, container, anchor = null, parentComponent = null, parentSuspense = null, isSVG = false, slotScopeIds = null, optimized = false) => { + if (n1 && !isSameVNodeType(n1, n2)) { + anchor = getNextHostNode(n1); + unmount(n1, parentComponent, parentSuspense, true); + n1 = null; + } + if (n2.patchFlag === -2) { + optimized = false; + n2.dynamicChildren = null; + } + const { type, ref: ref2, shapeFlag } = n2; + switch (type) { + case Text$1: + processText(n1, n2, container, anchor); + break; + case Comment$1: + processCommentNode(n1, n2, container, anchor); + break; + case Static: + if (n1 == null) { + mountStaticNode(n2, container, anchor, isSVG); + } + break; + case Fragment: + processFragment(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized); + break; + default: + if (shapeFlag & 1) { + processElement(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized); + } else if (shapeFlag & 6) { + processComponent(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized); + } else if (shapeFlag & 64) { + type.process(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, internals); + } else if (shapeFlag & 128) { + type.process(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, internals); + } else + ; + } + if (ref2 != null && parentComponent) { + setRef(ref2, n1 && n1.ref, parentSuspense, n2 || n1, !n2); + } + }; + const processText = (n1, n2, container, anchor) => { + if (n1 == null) { + hostInsert(n2.el = hostCreateText(n2.children), container, anchor); + } else { + const el = n2.el = n1.el; + if (n2.children !== n1.children) { + hostSetText(el, n2.children); + } + } + }; + const processCommentNode = (n1, n2, container, anchor) => { + if (n1 == null) { + hostInsert(n2.el = hostCreateComment(n2.children || ""), container, anchor); + } else { + n2.el = n1.el; + } + }; + const mountStaticNode = (n2, container, anchor, isSVG) => { + [n2.el, n2.anchor] = hostInsertStaticContent(n2.children, container, anchor, isSVG, n2.el && [n2.el, n2.anchor]); + }; + const moveStaticNode = ({ el, anchor }, container, nextSibling) => { + let next; + while (el && el !== anchor) { + next = hostNextSibling(el); + hostInsert(el, container, nextSibling); + el = next; + } + hostInsert(anchor, container, nextSibling); + }; + const removeStaticNode = ({ el, anchor }) => { + let next; + while (el && el !== anchor) { + next = hostNextSibling(el); + hostRemove(el); + el = next; + } + hostRemove(anchor); + }; + const processElement = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => { + isSVG = isSVG || n2.type === "svg"; + if (n1 == null) { + mountElement(n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized); + } else { + patchElement(n1, n2, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized); + } + }; + const mountElement = (vnode, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => { + let el; + let vnodeHook; + const { type, props: props2, shapeFlag, transition, patchFlag, dirs } = vnode; + if (vnode.el && hostCloneNode !== void 0 && patchFlag === -1) { + el = vnode.el = hostCloneNode(vnode.el); + } else { + el = vnode.el = hostCreateElement(vnode.type, isSVG, props2 && props2.is, props2); + if (shapeFlag & 8) { + hostSetElementText(el, vnode.children); + } else if (shapeFlag & 16) { + mountChildren(vnode.children, el, null, parentComponent, parentSuspense, isSVG && type !== "foreignObject", slotScopeIds, optimized || !!vnode.dynamicChildren); + } + if (dirs) { + invokeDirectiveHook(vnode, null, parentComponent, "created"); + } + if (props2) { + for (const key in props2) { + if (!isReservedProp(key)) { + hostPatchProp(el, key, null, props2[key], isSVG, vnode.children, parentComponent, parentSuspense, unmountChildren); + } + } + if (vnodeHook = props2.onVnodeBeforeMount) { + invokeVNodeHook(vnodeHook, parentComponent, vnode); + } + } + setScopeId(el, vnode, vnode.scopeId, slotScopeIds, parentComponent); + } + if (dirs) { + invokeDirectiveHook(vnode, null, parentComponent, "beforeMount"); + } + const needCallTransitionHooks = (!parentSuspense || parentSuspense && !parentSuspense.pendingBranch) && transition && !transition.persisted; + if (needCallTransitionHooks) { + transition.beforeEnter(el); + } + hostInsert(el, container, anchor); + if ((vnodeHook = props2 && props2.onVnodeMounted) || needCallTransitionHooks || dirs) { + queuePostRenderEffect(() => { + vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, vnode); + needCallTransitionHooks && transition.enter(el); + dirs && invokeDirectiveHook(vnode, null, parentComponent, "mounted"); + }, parentSuspense); + } + }; + const setScopeId = (el, vnode, scopeId, slotScopeIds, parentComponent) => { + if (scopeId) { + hostSetScopeId(el, scopeId); + } + if (slotScopeIds) { + for (let i = 0; i < slotScopeIds.length; i++) { + hostSetScopeId(el, slotScopeIds[i]); + } + } + if (parentComponent) { + let subTree = parentComponent.subTree; + if (vnode === subTree) { + const parentVNode = parentComponent.vnode; + setScopeId(el, parentVNode, parentVNode.scopeId, parentVNode.slotScopeIds, parentComponent.parent); + } + } + }; + const mountChildren = (children, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, start = 0) => { + for (let i = start; i < children.length; i++) { + const child = children[i] = optimized ? cloneIfMounted(children[i]) : normalizeVNode(children[i]); + patch(null, child, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized); + } + }; + const patchElement = (n1, n2, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => { + const el = n2.el = n1.el; + let { patchFlag, dynamicChildren, dirs } = n2; + patchFlag |= n1.patchFlag & 16; + const oldProps = n1.props || EMPTY_OBJ; + const newProps = n2.props || EMPTY_OBJ; + let vnodeHook; + if (vnodeHook = newProps.onVnodeBeforeUpdate) { + invokeVNodeHook(vnodeHook, parentComponent, n2, n1); + } + if (dirs) { + invokeDirectiveHook(n2, n1, parentComponent, "beforeUpdate"); + } + if (patchFlag > 0) { + if (patchFlag & 16) { + patchProps(el, n2, oldProps, newProps, parentComponent, parentSuspense, isSVG); + } else { + if (patchFlag & 2) { + if (oldProps.class !== newProps.class) { + hostPatchProp(el, "class", null, newProps.class, isSVG); + } + } + if (patchFlag & 4) { + hostPatchProp(el, "style", oldProps.style, newProps.style, isSVG); + } + if (patchFlag & 8) { + const propsToUpdate = n2.dynamicProps; + for (let i = 0; i < propsToUpdate.length; i++) { + const key = propsToUpdate[i]; + const prev = oldProps[key]; + const next = newProps[key]; + if (next !== prev || hostForcePatchProp && hostForcePatchProp(el, key)) { + hostPatchProp(el, key, prev, next, isSVG, n1.children, parentComponent, parentSuspense, unmountChildren); + } + } + } + } + if (patchFlag & 1) { + if (n1.children !== n2.children) { + hostSetElementText(el, n2.children); + } + } + } else if (!optimized && dynamicChildren == null) { + patchProps(el, n2, oldProps, newProps, parentComponent, parentSuspense, isSVG); + } + const areChildrenSVG = isSVG && n2.type !== "foreignObject"; + if (dynamicChildren) { + patchBlockChildren(n1.dynamicChildren, dynamicChildren, el, parentComponent, parentSuspense, areChildrenSVG, slotScopeIds); + } else if (!optimized) { + patchChildren(n1, n2, el, null, parentComponent, parentSuspense, areChildrenSVG, slotScopeIds, false); + } + if ((vnodeHook = newProps.onVnodeUpdated) || dirs) { + queuePostRenderEffect(() => { + vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, n2, n1); + dirs && invokeDirectiveHook(n2, n1, parentComponent, "updated"); + }, parentSuspense); + } + }; + const patchBlockChildren = (oldChildren, newChildren, fallbackContainer, parentComponent, parentSuspense, isSVG, slotScopeIds) => { + for (let i = 0; i < newChildren.length; i++) { + const oldVNode = oldChildren[i]; + const newVNode = newChildren[i]; + const container = oldVNode.el && (oldVNode.type === Fragment || !isSameVNodeType(oldVNode, newVNode) || oldVNode.shapeFlag & 6 || oldVNode.shapeFlag & 64) ? hostParentNode(oldVNode.el) : fallbackContainer; + patch(oldVNode, newVNode, container, null, parentComponent, parentSuspense, isSVG, slotScopeIds, true); + } + }; + const patchProps = (el, vnode, oldProps, newProps, parentComponent, parentSuspense, isSVG) => { + if (oldProps !== newProps) { + for (const key in newProps) { + if (isReservedProp(key)) + continue; + const next = newProps[key]; + const prev = oldProps[key]; + if (next !== prev || hostForcePatchProp && hostForcePatchProp(el, key)) { + hostPatchProp(el, key, prev, next, isSVG, vnode.children, parentComponent, parentSuspense, unmountChildren); + } + } + if (oldProps !== EMPTY_OBJ) { + for (const key in oldProps) { + if (!isReservedProp(key) && !(key in newProps)) { + hostPatchProp(el, key, oldProps[key], null, isSVG, vnode.children, parentComponent, parentSuspense, unmountChildren); + } + } + } + } + }; + const processFragment = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => { + const fragmentStartAnchor = n2.el = n1 ? n1.el : hostCreateText(""); + const fragmentEndAnchor = n2.anchor = n1 ? n1.anchor : hostCreateText(""); + let { patchFlag, dynamicChildren, slotScopeIds: fragmentSlotScopeIds } = n2; + if (dynamicChildren) { + optimized = true; + } + if (fragmentSlotScopeIds) { + slotScopeIds = slotScopeIds ? slotScopeIds.concat(fragmentSlotScopeIds) : fragmentSlotScopeIds; + } + if (n1 == null) { + hostInsert(fragmentStartAnchor, container, anchor); + hostInsert(fragmentEndAnchor, container, anchor); + mountChildren(n2.children, container, fragmentEndAnchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized); + } else { + if (patchFlag > 0 && patchFlag & 64 && dynamicChildren && n1.dynamicChildren) { + patchBlockChildren(n1.dynamicChildren, dynamicChildren, container, parentComponent, parentSuspense, isSVG, slotScopeIds); + if (n2.key != null || parentComponent && n2 === parentComponent.subTree) { + traverseStaticChildren(n1, n2, true); + } + } else { + patchChildren(n1, n2, container, fragmentEndAnchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized); + } + } + }; + const processComponent = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => { + n2.slotScopeIds = slotScopeIds; + if (n1 == null) { + if (n2.shapeFlag & 512) { + parentComponent.ctx.activate(n2, container, anchor, isSVG, optimized); + } else { + mountComponent(n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized); + } + } else { + updateComponent(n1, n2, optimized); + } + }; + const mountComponent = (initialVNode, container, anchor, parentComponent, parentSuspense, isSVG, optimized) => { + const instance = initialVNode.component = createComponentInstance(initialVNode, parentComponent, parentSuspense); + if (isKeepAlive(initialVNode)) { + instance.ctx.renderer = internals; + } + { + setupComponent(instance); + } + if (instance.asyncDep) { + parentSuspense && parentSuspense.registerDep(instance, setupRenderEffect); + if (!initialVNode.el) { + const placeholder = instance.subTree = createVNode(Comment$1); + processCommentNode(null, placeholder, container, anchor); + } + return; + } + setupRenderEffect(instance, initialVNode, container, anchor, parentSuspense, isSVG, optimized); + }; + const updateComponent = (n1, n2, optimized) => { + const instance = n2.component = n1.component; + if (shouldUpdateComponent(n1, n2, optimized)) { + if (instance.asyncDep && !instance.asyncResolved) { + updateComponentPreRender(instance, n2, optimized); + return; + } else { + instance.next = n2; + invalidateJob(instance.update); + instance.update(); + } + } else { + n2.component = n1.component; + n2.el = n1.el; + instance.vnode = n2; + } + }; + const setupRenderEffect = (instance, initialVNode, container, anchor, parentSuspense, isSVG, optimized) => { + instance.update = effect(function componentEffect() { + if (!instance.isMounted) { + let vnodeHook; + const { el, props: props2 } = initialVNode; + const { bm, m, parent } = instance; + if (bm) { + invokeArrayFns(bm); + } + if (vnodeHook = props2 && props2.onVnodeBeforeMount) { + invokeVNodeHook(vnodeHook, parent, initialVNode); + } + if (el && hydrateNode) { + const hydrateSubTree = () => { + instance.subTree = renderComponentRoot(instance); + hydrateNode(el, instance.subTree, instance, parentSuspense, null); + }; + if (isAsyncWrapper(initialVNode)) { + initialVNode.type.__asyncLoader().then(() => !instance.isUnmounted && hydrateSubTree()); + } else { + hydrateSubTree(); + } + } else { + const subTree = instance.subTree = renderComponentRoot(instance); + patch(null, subTree, container, anchor, instance, parentSuspense, isSVG); + initialVNode.el = subTree.el; + } + if (m) { + queuePostRenderEffect(m, parentSuspense); + } + if (vnodeHook = props2 && props2.onVnodeMounted) { + const scopedInitialVNode = initialVNode; + queuePostRenderEffect(() => invokeVNodeHook(vnodeHook, parent, scopedInitialVNode), parentSuspense); + } + if (initialVNode.shapeFlag & 256) { + instance.a && queuePostRenderEffect(instance.a, parentSuspense); + } + instance.isMounted = true; + initialVNode = container = anchor = null; + } else { + let { next, bu, u, parent, vnode } = instance; + let originNext = next; + let vnodeHook; + if (next) { + next.el = vnode.el; + updateComponentPreRender(instance, next, optimized); + } else { + next = vnode; + } + if (bu) { + invokeArrayFns(bu); + } + if (vnodeHook = next.props && next.props.onVnodeBeforeUpdate) { + invokeVNodeHook(vnodeHook, parent, next, vnode); + } + const nextTree = renderComponentRoot(instance); + const prevTree = instance.subTree; + instance.subTree = nextTree; + patch(prevTree, nextTree, hostParentNode(prevTree.el), getNextHostNode(prevTree), instance, parentSuspense, isSVG); + next.el = nextTree.el; + if (originNext === null) { + updateHOCHostEl(instance, nextTree.el); + } + if (u) { + queuePostRenderEffect(u, parentSuspense); + } + if (vnodeHook = next.props && next.props.onVnodeUpdated) { + queuePostRenderEffect(() => invokeVNodeHook(vnodeHook, parent, next, vnode), parentSuspense); + } + } + }, prodEffectOptions); + }; + const updateComponentPreRender = (instance, nextVNode, optimized) => { + nextVNode.component = instance; + const prevProps = instance.vnode.props; + instance.vnode = nextVNode; + instance.next = null; + updateProps(instance, nextVNode.props, prevProps, optimized); + updateSlots(instance, nextVNode.children, optimized); + pauseTracking(); + flushPreFlushCbs(void 0, instance.update); + resetTracking(); + }; + const patchChildren = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized = false) => { + const c1 = n1 && n1.children; + const prevShapeFlag = n1 ? n1.shapeFlag : 0; + const c2 = n2.children; + const { patchFlag, shapeFlag } = n2; + if (patchFlag > 0) { + if (patchFlag & 128) { + patchKeyedChildren(c1, c2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized); + return; + } else if (patchFlag & 256) { + patchUnkeyedChildren(c1, c2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized); + return; + } + } + if (shapeFlag & 8) { + if (prevShapeFlag & 16) { + unmountChildren(c1, parentComponent, parentSuspense); + } + if (c2 !== c1) { + hostSetElementText(container, c2); + } + } else { + if (prevShapeFlag & 16) { + if (shapeFlag & 16) { + patchKeyedChildren(c1, c2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized); + } else { + unmountChildren(c1, parentComponent, parentSuspense, true); + } + } else { + if (prevShapeFlag & 8) { + hostSetElementText(container, ""); + } + if (shapeFlag & 16) { + mountChildren(c2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized); + } + } + } + }; + const patchUnkeyedChildren = (c1, c2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => { + c1 = c1 || EMPTY_ARR; + c2 = c2 || EMPTY_ARR; + const oldLength = c1.length; + const newLength = c2.length; + const commonLength = Math.min(oldLength, newLength); + let i; + for (i = 0; i < commonLength; i++) { + const nextChild = c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]); + patch(c1[i], nextChild, container, null, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized); + } + if (oldLength > newLength) { + unmountChildren(c1, parentComponent, parentSuspense, true, false, commonLength); + } else { + mountChildren(c2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, commonLength); + } + }; + const patchKeyedChildren = (c1, c2, container, parentAnchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => { + let i = 0; + const l2 = c2.length; + let e1 = c1.length - 1; + let e2 = l2 - 1; + while (i <= e1 && i <= e2) { + const n1 = c1[i]; + const n2 = c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]); + if (isSameVNodeType(n1, n2)) { + patch(n1, n2, container, null, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized); + } else { + break; + } + i++; + } + while (i <= e1 && i <= e2) { + const n1 = c1[e1]; + const n2 = c2[e2] = optimized ? cloneIfMounted(c2[e2]) : normalizeVNode(c2[e2]); + if (isSameVNodeType(n1, n2)) { + patch(n1, n2, container, null, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized); + } else { + break; + } + e1--; + e2--; + } + if (i > e1) { + if (i <= e2) { + const nextPos = e2 + 1; + const anchor = nextPos < l2 ? c2[nextPos].el : parentAnchor; + while (i <= e2) { + patch(null, c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]), container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized); + i++; + } + } + } else if (i > e2) { + while (i <= e1) { + unmount(c1[i], parentComponent, parentSuspense, true); + i++; + } + } else { + const s1 = i; + const s2 = i; + const keyToNewIndexMap = new Map(); + for (i = s2; i <= e2; i++) { + const nextChild = c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]); + if (nextChild.key != null) { + keyToNewIndexMap.set(nextChild.key, i); + } + } + let j; + let patched = 0; + const toBePatched = e2 - s2 + 1; + let moved = false; + let maxNewIndexSoFar = 0; + const newIndexToOldIndexMap = new Array(toBePatched); + for (i = 0; i < toBePatched; i++) + newIndexToOldIndexMap[i] = 0; + for (i = s1; i <= e1; i++) { + const prevChild = c1[i]; + if (patched >= toBePatched) { + unmount(prevChild, parentComponent, parentSuspense, true); + continue; + } + let newIndex; + if (prevChild.key != null) { + newIndex = keyToNewIndexMap.get(prevChild.key); + } else { + for (j = s2; j <= e2; j++) { + if (newIndexToOldIndexMap[j - s2] === 0 && isSameVNodeType(prevChild, c2[j])) { + newIndex = j; + break; + } + } + } + if (newIndex === void 0) { + unmount(prevChild, parentComponent, parentSuspense, true); + } else { + newIndexToOldIndexMap[newIndex - s2] = i + 1; + if (newIndex >= maxNewIndexSoFar) { + maxNewIndexSoFar = newIndex; + } else { + moved = true; + } + patch(prevChild, c2[newIndex], container, null, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized); + patched++; + } + } + const increasingNewIndexSequence = moved ? getSequence(newIndexToOldIndexMap) : EMPTY_ARR; + j = increasingNewIndexSequence.length - 1; + for (i = toBePatched - 1; i >= 0; i--) { + const nextIndex = s2 + i; + const nextChild = c2[nextIndex]; + const anchor = nextIndex + 1 < l2 ? c2[nextIndex + 1].el : parentAnchor; + if (newIndexToOldIndexMap[i] === 0) { + patch(null, nextChild, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized); + } else if (moved) { + if (j < 0 || i !== increasingNewIndexSequence[j]) { + move(nextChild, container, anchor, 2); + } else { + j--; + } + } + } + } + }; + const move = (vnode, container, anchor, moveType, parentSuspense = null) => { + const { el, type, transition, children, shapeFlag } = vnode; + if (shapeFlag & 6) { + move(vnode.component.subTree, container, anchor, moveType); + return; + } + if (shapeFlag & 128) { + vnode.suspense.move(container, anchor, moveType); + return; + } + if (shapeFlag & 64) { + type.move(vnode, container, anchor, internals); + return; + } + if (type === Fragment) { + hostInsert(el, container, anchor); + for (let i = 0; i < children.length; i++) { + move(children[i], container, anchor, moveType); + } + hostInsert(vnode.anchor, container, anchor); + return; + } + if (type === Static) { + moveStaticNode(vnode, container, anchor); + return; + } + const needTransition = moveType !== 2 && shapeFlag & 1 && transition; + if (needTransition) { + if (moveType === 0) { + transition.beforeEnter(el); + hostInsert(el, container, anchor); + queuePostRenderEffect(() => transition.enter(el), parentSuspense); + } else { + const { leave, delayLeave, afterLeave } = transition; + const remove3 = () => hostInsert(el, container, anchor); + const performLeave = () => { + leave(el, () => { + remove3(); + afterLeave && afterLeave(); + }); + }; + if (delayLeave) { + delayLeave(el, remove3, performLeave); + } else { + performLeave(); + } + } + } else { + hostInsert(el, container, anchor); + } + }; + const unmount = (vnode, parentComponent, parentSuspense, doRemove = false, optimized = false) => { + const { type, props: props2, ref: ref2, children, dynamicChildren, shapeFlag, patchFlag, dirs } = vnode; + if (ref2 != null) { + setRef(ref2, null, parentSuspense, vnode, true); + } + if (shapeFlag & 256) { + parentComponent.ctx.deactivate(vnode); + return; + } + const shouldInvokeDirs = shapeFlag & 1 && dirs; + let vnodeHook; + if (vnodeHook = props2 && props2.onVnodeBeforeUnmount) { + invokeVNodeHook(vnodeHook, parentComponent, vnode); + } + if (shapeFlag & 6) { + unmountComponent(vnode.component, parentSuspense, doRemove); + } else { + if (shapeFlag & 128) { + vnode.suspense.unmount(parentSuspense, doRemove); + return; + } + if (shouldInvokeDirs) { + invokeDirectiveHook(vnode, null, parentComponent, "beforeUnmount"); + } + if (shapeFlag & 64) { + vnode.type.remove(vnode, parentComponent, parentSuspense, optimized, internals, doRemove); + } else if (dynamicChildren && (type !== Fragment || patchFlag > 0 && patchFlag & 64)) { + unmountChildren(dynamicChildren, parentComponent, parentSuspense, false, true); + } else if (type === Fragment && (patchFlag & 128 || patchFlag & 256) || !optimized && shapeFlag & 16) { + unmountChildren(children, parentComponent, parentSuspense); + } + if (doRemove) { + remove2(vnode); + } + } + if ((vnodeHook = props2 && props2.onVnodeUnmounted) || shouldInvokeDirs) { + queuePostRenderEffect(() => { + vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, vnode); + shouldInvokeDirs && invokeDirectiveHook(vnode, null, parentComponent, "unmounted"); + }, parentSuspense); + } + }; + const remove2 = (vnode) => { + const { type, el, anchor, transition } = vnode; + if (type === Fragment) { + removeFragment(el, anchor); + return; + } + if (type === Static) { + removeStaticNode(vnode); + return; + } + const performRemove = () => { + hostRemove(el); + if (transition && !transition.persisted && transition.afterLeave) { + transition.afterLeave(); + } + }; + if (vnode.shapeFlag & 1 && transition && !transition.persisted) { + const { leave, delayLeave } = transition; + const performLeave = () => leave(el, performRemove); + if (delayLeave) { + delayLeave(vnode.el, performRemove, performLeave); + } else { + performLeave(); + } + } else { + performRemove(); + } + }; + const removeFragment = (cur, end) => { + let next; + while (cur !== end) { + next = hostNextSibling(cur); + hostRemove(cur); + cur = next; + } + hostRemove(end); + }; + const unmountComponent = (instance, parentSuspense, doRemove) => { + const { bum, effects, update, subTree, um } = instance; + if (bum) { + invokeArrayFns(bum); + } + if (effects) { + for (let i = 0; i < effects.length; i++) { + stop(effects[i]); + } + } + if (update) { + stop(update); + unmount(subTree, instance, parentSuspense, doRemove); + } + if (um) { + queuePostRenderEffect(um, parentSuspense); + } + queuePostRenderEffect(() => { + instance.isUnmounted = true; + }, parentSuspense); + if (parentSuspense && parentSuspense.pendingBranch && !parentSuspense.isUnmounted && instance.asyncDep && !instance.asyncResolved && instance.suspenseId === parentSuspense.pendingId) { + parentSuspense.deps--; + if (parentSuspense.deps === 0) { + parentSuspense.resolve(); + } + } + }; + const unmountChildren = (children, parentComponent, parentSuspense, doRemove = false, optimized = false, start = 0) => { + for (let i = start; i < children.length; i++) { + unmount(children[i], parentComponent, parentSuspense, doRemove, optimized); + } + }; + const getNextHostNode = (vnode) => { + if (vnode.shapeFlag & 6) { + return getNextHostNode(vnode.component.subTree); + } + if (vnode.shapeFlag & 128) { + return vnode.suspense.next(); + } + return hostNextSibling(vnode.anchor || vnode.el); + }; + const render = (vnode, container, isSVG) => { + if (vnode == null) { + if (container._vnode) { + unmount(container._vnode, null, null, true); + } + } else { + patch(container._vnode || null, vnode, container, null, null, null, isSVG); + } + flushPostFlushCbs(); + container._vnode = vnode; + }; + const internals = { + p: patch, + um: unmount, + m: move, + r: remove2, + mt: mountComponent, + mc: mountChildren, + pc: patchChildren, + pbc: patchBlockChildren, + n: getNextHostNode, + o: options + }; + let hydrate; + let hydrateNode; + if (createHydrationFns) { + [hydrate, hydrateNode] = createHydrationFns(internals); + } + return { + render, + hydrate, + createApp: createAppAPI(render, hydrate) + }; + } + function invokeVNodeHook(hook, instance, vnode, prevVNode = null) { + callWithAsyncErrorHandling(hook, instance, 7, [ + vnode, + prevVNode + ]); + } + function traverseStaticChildren(n1, n2, shallow = false) { + const ch1 = n1.children; + const ch2 = n2.children; + if (isArray(ch1) && isArray(ch2)) { + for (let i = 0; i < ch1.length; i++) { + const c1 = ch1[i]; + let c2 = ch2[i]; + if (c2.shapeFlag & 1 && !c2.dynamicChildren) { + if (c2.patchFlag <= 0 || c2.patchFlag === 32) { + c2 = ch2[i] = cloneIfMounted(ch2[i]); + c2.el = c1.el; + } + if (!shallow) + traverseStaticChildren(c1, c2); + } + } + } + } + function getSequence(arr) { + const p2 = arr.slice(); + const result = [0]; + let i, j, u, v, c; + const len = arr.length; + for (i = 0; i < len; i++) { + const arrI = arr[i]; + if (arrI !== 0) { + j = result[result.length - 1]; + if (arr[j] < arrI) { + p2[i] = j; + result.push(i); + continue; + } + u = 0; + v = result.length - 1; + while (u < v) { + c = (u + v) / 2 | 0; + if (arr[result[c]] < arrI) { + u = c + 1; + } else { + v = c; + } + } + if (arrI < arr[result[u]]) { + if (u > 0) { + p2[i] = result[u - 1]; + } + result[u] = i; + } + } + } + u = result.length; + v = result[u - 1]; + while (u-- > 0) { + result[u] = v; + v = p2[v]; + } + return result; + } + const isTeleport = (type) => type.__isTeleport; + const NULL_DYNAMIC_COMPONENT = Symbol(); + const Fragment = Symbol(void 0); + const Text$1 = Symbol(void 0); + const Comment$1 = Symbol(void 0); + const Static = Symbol(void 0); + let currentBlock = null; + let isBlockTreeEnabled = 1; + function setBlockTracking(value) { + isBlockTreeEnabled += value; + } + function isVNode(value) { + return value ? value.__v_isVNode === true : false; + } + function isSameVNodeType(n1, n2) { + return n1.type === n2.type && n1.key === n2.key; + } + const InternalObjectKey = `__vInternal`; + const normalizeKey = ({ key }) => key != null ? key : null; + const normalizeRef = ({ ref: ref2 }) => { + return ref2 != null ? isString$1(ref2) || isRef(ref2) || isFunction(ref2) ? { i: currentRenderingInstance, r: ref2 } : ref2 : null; + }; + const createVNode = _createVNode; + function _createVNode(type, props2 = null, children = null, patchFlag = 0, dynamicProps = null, isBlockNode = false) { + if (!type || type === NULL_DYNAMIC_COMPONENT) { + type = Comment$1; + } + if (isVNode(type)) { + const cloned = cloneVNode(type, props2, true); + if (children) { + normalizeChildren(cloned, children); + } + return cloned; + } + if (isClassComponent(type)) { + type = type.__vccOpts; + } + if (props2) { + if (isProxy(props2) || InternalObjectKey in props2) { + props2 = extend$1({}, props2); + } + let { class: klass, style } = props2; + if (klass && !isString$1(klass)) { + props2.class = normalizeClass(klass); + } + if (isObject$1(style)) { + if (isProxy(style) && !isArray(style)) { + style = extend$1({}, style); + } + props2.style = normalizeStyle(style); + } + } + const shapeFlag = isString$1(type) ? 1 : isSuspense(type) ? 128 : isTeleport(type) ? 64 : isObject$1(type) ? 4 : isFunction(type) ? 2 : 0; + const vnode = { + __v_isVNode: true, + __v_skip: true, + type, + props: props2, + key: props2 && normalizeKey(props2), + ref: props2 && normalizeRef(props2), + scopeId: currentScopeId, + slotScopeIds: null, + children: null, + component: null, + suspense: null, + ssContent: null, + ssFallback: null, + dirs: null, + transition: null, + el: null, + anchor: null, + target: null, + targetAnchor: null, + staticCount: 0, + shapeFlag, + patchFlag, + dynamicProps, + dynamicChildren: null, + appContext: null + }; + normalizeChildren(vnode, children); + if (shapeFlag & 128) { + type.normalize(vnode); + } + if (isBlockTreeEnabled > 0 && !isBlockNode && currentBlock && (patchFlag > 0 || shapeFlag & 6) && patchFlag !== 32) { + currentBlock.push(vnode); + } + return vnode; + } + function cloneVNode(vnode, extraProps, mergeRef = false) { + const { props: props2, ref: ref2, patchFlag, children } = vnode; + const mergedProps = extraProps ? mergeProps(props2 || {}, extraProps) : props2; + const cloned = { + __v_isVNode: true, + __v_skip: true, + type: vnode.type, + props: mergedProps, + key: mergedProps && normalizeKey(mergedProps), + ref: extraProps && extraProps.ref ? mergeRef && ref2 ? isArray(ref2) ? ref2.concat(normalizeRef(extraProps)) : [ref2, normalizeRef(extraProps)] : normalizeRef(extraProps) : ref2, + scopeId: vnode.scopeId, + slotScopeIds: vnode.slotScopeIds, + children, + target: vnode.target, + targetAnchor: vnode.targetAnchor, + staticCount: vnode.staticCount, + shapeFlag: vnode.shapeFlag, + patchFlag: extraProps && vnode.type !== Fragment ? patchFlag === -1 ? 16 : patchFlag | 16 : patchFlag, + dynamicProps: vnode.dynamicProps, + dynamicChildren: vnode.dynamicChildren, + appContext: vnode.appContext, + dirs: vnode.dirs, + transition: vnode.transition, + component: vnode.component, + suspense: vnode.suspense, + ssContent: vnode.ssContent && cloneVNode(vnode.ssContent), + ssFallback: vnode.ssFallback && cloneVNode(vnode.ssFallback), + el: vnode.el, + anchor: vnode.anchor + }; + return cloned; + } + function createTextVNode(text = " ", flag = 0) { + return createVNode(Text$1, null, text, flag); + } + function normalizeVNode(child) { + if (child == null || typeof child === "boolean") { + return createVNode(Comment$1); + } else if (isArray(child)) { + return createVNode(Fragment, null, child.slice()); + } else if (typeof child === "object") { + return cloneIfMounted(child); + } else { + return createVNode(Text$1, null, String(child)); + } + } + function cloneIfMounted(child) { + return child.el === null ? child : cloneVNode(child); + } + function normalizeChildren(vnode, children) { + let type = 0; + const { shapeFlag } = vnode; + if (children == null) { + children = null; + } else if (isArray(children)) { + type = 16; + } else if (typeof children === "object") { + if (shapeFlag & 1 || shapeFlag & 64) { + const slot = children.default; + if (slot) { + slot._c && (slot._d = false); + normalizeChildren(vnode, slot()); + slot._c && (slot._d = true); + } + return; + } else { + type = 32; + const slotFlag = children._; + if (!slotFlag && !(InternalObjectKey in children)) { + children._ctx = currentRenderingInstance; + } else if (slotFlag === 3 && currentRenderingInstance) { + if (currentRenderingInstance.slots._ === 1) { + children._ = 1; + } else { + children._ = 2; + vnode.patchFlag |= 1024; + } + } + } + } else if (isFunction(children)) { + children = { default: children, _ctx: currentRenderingInstance }; + type = 32; + } else { + children = String(children); + if (shapeFlag & 64) { + type = 16; + children = [createTextVNode(children)]; + } else { + type = 8; + } + } + vnode.children = children; + vnode.shapeFlag |= type; + } + function mergeProps(...args) { + const ret = extend$1({}, args[0]); + for (let i = 1; i < args.length; i++) { + const toMerge = args[i]; + for (const key in toMerge) { + if (key === "class") { + if (ret.class !== toMerge.class) { + ret.class = normalizeClass([ret.class, toMerge.class]); + } + } else if (key === "style") { + ret.style = normalizeStyle([ret.style, toMerge.style]); + } else if (isOn(key)) { + const existing = ret[key]; + const incoming = toMerge[key]; + if (existing !== incoming) { + ret[key] = existing ? [].concat(existing, incoming) : incoming; + } + } else if (key !== "") { + ret[key] = toMerge[key]; + } + } + } + return ret; + } + const getPublicInstance = (i) => { + if (!i) + return null; + if (isStatefulComponent(i)) + return i.exposed ? i.exposed : i.proxy; + return getPublicInstance(i.parent); + }; + const publicPropertiesMap = extend$1(Object.create(null), { + $: (i) => i, + $el: (i) => i.vnode.el, + $data: (i) => i.data, + $props: (i) => i.props, + $attrs: (i) => i.attrs, + $slots: (i) => i.slots, + $refs: (i) => i.refs, + $parent: (i) => getPublicInstance(i.parent), + $root: (i) => getPublicInstance(i.root), + $emit: (i) => i.emit, + $options: (i) => resolveMergedOptions(i), + $forceUpdate: (i) => () => queueJob(i.update), + $nextTick: (i) => nextTick.bind(i.proxy), + $watch: (i) => instanceWatch.bind(i) + }); + const PublicInstanceProxyHandlers = { + get({ _: instance }, key) { + const { ctx, setupState, data, props: props2, accessCache, type, appContext } = instance; + let normalizedProps; + if (key[0] !== "$") { + const n = accessCache[key]; + if (n !== void 0) { + switch (n) { + case 0: + return setupState[key]; + case 1: + return data[key]; + case 3: + return ctx[key]; + case 2: + return props2[key]; + } + } else if (setupState !== EMPTY_OBJ && hasOwn$1(setupState, key)) { + accessCache[key] = 0; + return setupState[key]; + } else if (data !== EMPTY_OBJ && hasOwn$1(data, key)) { + accessCache[key] = 1; + return data[key]; + } else if ((normalizedProps = instance.propsOptions[0]) && hasOwn$1(normalizedProps, key)) { + accessCache[key] = 2; + return props2[key]; + } else if (ctx !== EMPTY_OBJ && hasOwn$1(ctx, key)) { + accessCache[key] = 3; + return ctx[key]; + } else if (shouldCacheAccess) { + accessCache[key] = 4; + } + } + const publicGetter = publicPropertiesMap[key]; + let cssModule, globalProperties; + if (publicGetter) { + if (key === "$attrs") { + track(instance, "get", key); + } + return publicGetter(instance); + } else if ((cssModule = type.__cssModules) && (cssModule = cssModule[key])) { + return cssModule; + } else if (ctx !== EMPTY_OBJ && hasOwn$1(ctx, key)) { + accessCache[key] = 3; + return ctx[key]; + } else if (globalProperties = appContext.config.globalProperties, hasOwn$1(globalProperties, key)) { + { + return globalProperties[key]; + } + } else + ; + }, + set({ _: instance }, key, value) { + const { data, setupState, ctx } = instance; + if (setupState !== EMPTY_OBJ && hasOwn$1(setupState, key)) { + setupState[key] = value; + } else if (data !== EMPTY_OBJ && hasOwn$1(data, key)) { + data[key] = value; + } else if (hasOwn$1(instance.props, key)) { + return false; + } + if (key[0] === "$" && key.slice(1) in instance) { + return false; + } else { + { + ctx[key] = value; + } + } + return true; + }, + has({ _: { data, setupState, accessCache, ctx, appContext, propsOptions } }, key) { + let normalizedProps; + return accessCache[key] !== void 0 || data !== EMPTY_OBJ && hasOwn$1(data, key) || setupState !== EMPTY_OBJ && hasOwn$1(setupState, key) || (normalizedProps = propsOptions[0]) && hasOwn$1(normalizedProps, key) || hasOwn$1(ctx, key) || hasOwn$1(publicPropertiesMap, key) || hasOwn$1(appContext.config.globalProperties, key); + } + }; + const RuntimeCompiledPublicInstanceProxyHandlers = extend$1({}, PublicInstanceProxyHandlers, { + get(target, key) { + if (key === Symbol.unscopables) { + return; + } + return PublicInstanceProxyHandlers.get(target, key, target); + }, + has(_, key) { + const has2 = key[0] !== "_" && !isGloballyWhitelisted(key); + return has2; + } + }); + const emptyAppContext = createAppContext(); + let uid$2 = 0; + function createComponentInstance(vnode, parent, suspense) { + const type = vnode.type; + const appContext = (parent ? parent.appContext : vnode.appContext) || emptyAppContext; + const instance = { + uid: uid$2++, + vnode, + type, + parent, + appContext, + root: null, + next: null, + subTree: null, + update: null, + render: null, + proxy: null, + exposed: null, + exposeProxy: null, + withProxy: null, + effects: null, + provides: parent ? parent.provides : Object.create(appContext.provides), + accessCache: null, + renderCache: [], + components: null, + directives: null, + propsOptions: normalizePropsOptions(type, appContext), + emitsOptions: normalizeEmitsOptions(type, appContext), + emit: null, + emitted: null, + propsDefaults: EMPTY_OBJ, + inheritAttrs: type.inheritAttrs, + ctx: EMPTY_OBJ, + data: EMPTY_OBJ, + props: EMPTY_OBJ, + attrs: EMPTY_OBJ, + slots: EMPTY_OBJ, + refs: EMPTY_OBJ, + setupState: EMPTY_OBJ, + setupContext: null, + suspense, + suspenseId: suspense ? suspense.pendingId : 0, + asyncDep: null, + asyncResolved: false, + isMounted: false, + isUnmounted: false, + isDeactivated: false, + bc: null, + c: null, + bm: null, + m: null, + bu: null, + u: null, + um: null, + bum: null, + da: null, + a: null, + rtg: null, + rtc: null, + ec: null, + sp: null + }; + { + instance.ctx = { _: instance }; + } + instance.root = parent ? parent.root : instance; + instance.emit = emit.bind(null, instance); + return instance; + } + let currentInstance = null; + const getCurrentInstance = () => currentInstance || currentRenderingInstance; + const setCurrentInstance = (instance) => { + currentInstance = instance; + }; + function isStatefulComponent(instance) { + return instance.vnode.shapeFlag & 4; + } + let isInSSRComponentSetup = false; + function setupComponent(instance, isSSR = false) { + isInSSRComponentSetup = isSSR; + const { props: props2, children } = instance.vnode; + const isStateful = isStatefulComponent(instance); + initProps(instance, props2, isStateful, isSSR); + initSlots(instance, children); + const setupResult = isStateful ? setupStatefulComponent(instance, isSSR) : void 0; + isInSSRComponentSetup = false; + return setupResult; + } + function setupStatefulComponent(instance, isSSR) { + const Component = instance.type; + instance.accessCache = Object.create(null); + instance.proxy = markRaw(new Proxy(instance.ctx, PublicInstanceProxyHandlers)); + const { setup } = Component; + if (setup) { + const setupContext = instance.setupContext = setup.length > 1 ? createSetupContext(instance) : null; + currentInstance = instance; + pauseTracking(); + const setupResult = callWithErrorHandling(setup, instance, 0, [instance.props, setupContext]); + resetTracking(); + currentInstance = null; + if (isPromise(setupResult)) { + if (isSSR) { + return setupResult.then((resolvedResult) => { + handleSetupResult(instance, resolvedResult); + }).catch((e) => { + handleError(e, instance, 0); + }); + } else { + instance.asyncDep = setupResult; + } + } else { + handleSetupResult(instance, setupResult); + } + } else { + finishComponentSetup(instance); + } + } + function handleSetupResult(instance, setupResult, isSSR) { + if (isFunction(setupResult)) { + { + instance.render = setupResult; + } + } else if (isObject$1(setupResult)) { + instance.setupState = proxyRefs(setupResult); + } else + ; + finishComponentSetup(instance); + } + function finishComponentSetup(instance, isSSR, skipOptions) { + const Component = instance.type; + if (!instance.render) { + instance.render = Component.render || NOOP; + if (instance.render._rc) { + instance.withProxy = new Proxy(instance.ctx, RuntimeCompiledPublicInstanceProxyHandlers); + } + } + { + currentInstance = instance; + pauseTracking(); + applyOptions(instance); + resetTracking(); + currentInstance = null; + } + } + function createSetupContext(instance) { + const expose = (exposed) => { + instance.exposed = exposed || {}; + }; + { + return { + attrs: instance.attrs, + slots: instance.slots, + emit: instance.emit, + expose + }; + } + } + function getExposeProxy(instance) { + if (instance.exposed) { + return instance.exposeProxy || (instance.exposeProxy = new Proxy(proxyRefs(markRaw(instance.exposed)), { + get(target, key) { + if (key in target) { + return target[key]; + } else if (key in publicPropertiesMap) { + return publicPropertiesMap[key](instance); + } + } + })); + } + } + function recordInstanceBoundEffect(effect2, instance = currentInstance) { + if (instance) { + (instance.effects || (instance.effects = [])).push(effect2); + } + } + const classifyRE = /(?:^|[-_])(\w)/g; + const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, ""); + function getComponentName(Component) { + return isFunction(Component) ? Component.displayName || Component.name : Component.name; + } + function formatComponentName(instance, Component, isRoot = false) { + let name = getComponentName(Component); + if (!name && Component.__file) { + const match = Component.__file.match(/([^/\\]+)\.\w+$/); + if (match) { + name = match[1]; + } + } + if (!name && instance && instance.parent) { + const inferFromRegistry = (registry) => { + for (const key in registry) { + if (registry[key] === Component) { + return key; + } + } + }; + name = inferFromRegistry(instance.components || instance.parent.type.components) || inferFromRegistry(instance.appContext.components); + } + return name ? classify(name) : isRoot ? `App` : `Anonymous`; + } + function isClassComponent(value) { + return isFunction(value) && "__vccOpts" in value; + } + function computed$1(getterOrOptions) { + const c = computed(getterOrOptions); + recordInstanceBoundEffect(c.effect); + return c; + } + function h(type, propsOrChildren, children) { + const l = arguments.length; + if (l === 2) { + if (isObject$1(propsOrChildren) && !isArray(propsOrChildren)) { + if (isVNode(propsOrChildren)) { + return createVNode(type, null, [propsOrChildren]); + } + return createVNode(type, propsOrChildren); + } else { + return createVNode(type, null, propsOrChildren); + } + } else { + if (l > 3) { + children = Array.prototype.slice.call(arguments, 2); + } else if (l === 3 && isVNode(children)) { + children = [children]; + } + return createVNode(type, propsOrChildren, children); + } + } + const version = "3.1.2"; + const svgNS = "http://www.w3.org/2000/svg"; + const doc = typeof document !== "undefined" ? document : null; + const nodeOps = { + insert: (child, parent, anchor) => { + parent.insertBefore(child, anchor || null); + }, + remove: (child) => { + const parent = child.parentNode; + if (parent) { + parent.removeChild(child); + } + }, + createElement: (tag, isSVG, is, props2) => { + const el = isSVG ? doc.createElementNS(svgNS, tag) : doc.createElement(tag, is ? { is } : void 0); + if (tag === "select" && props2 && props2.multiple != null) { + el.setAttribute("multiple", props2.multiple); + } + return el; + }, + createText: (text) => doc.createTextNode(text), + createComment: (text) => doc.createComment(text), + setText: (node, text) => { + node.nodeValue = text; + }, + setElementText: (el, text) => { + el.textContent = text; + }, + parentNode: (node) => node.parentNode, + nextSibling: (node) => node.nextSibling, + querySelector: (selector) => doc.querySelector(selector), + setScopeId(el, id) { + el.setAttribute(id, ""); + }, + cloneNode(el) { + const cloned = el.cloneNode(true); + if (`_value` in el) { + cloned._value = el._value; + } + return cloned; + }, + insertStaticContent(content, parent, anchor, isSVG, cached) { + if (cached) { + let [cachedFirst, cachedLast] = cached; + let first, last; + while (true) { + let node = cachedFirst.cloneNode(true); + if (!first) + first = node; + parent.insertBefore(node, anchor); + if (cachedFirst === cachedLast) { + last = node; + break; + } + cachedFirst = cachedFirst.nextSibling; + } + return [first, last]; + } + const before = anchor ? anchor.previousSibling : parent.lastChild; + if (anchor) { + let insertionPoint; + let usingTempInsertionPoint = false; + if (anchor instanceof Element) { + insertionPoint = anchor; + } else { + usingTempInsertionPoint = true; + insertionPoint = isSVG ? doc.createElementNS(svgNS, "g") : doc.createElement("div"); + parent.insertBefore(insertionPoint, anchor); + } + insertionPoint.insertAdjacentHTML("beforebegin", content); + if (usingTempInsertionPoint) { + parent.removeChild(insertionPoint); + } + } else { + parent.insertAdjacentHTML("beforeend", content); + } + return [ + before ? before.nextSibling : parent.firstChild, + anchor ? anchor.previousSibling : parent.lastChild + ]; + } + }; + function patchClass(el, value, isSVG) { + if (value == null) { + value = ""; + } + if (isSVG) { + el.setAttribute("class", value); + } else { + const transitionClasses = el._vtc; + if (transitionClasses) { + value = (value ? [value, ...transitionClasses] : [...transitionClasses]).join(" "); + } + el.className = value; + } + } + function patchStyle(el, prev, next) { + const style = el.style; + if (!next) { + el.removeAttribute("style"); + } else if (isString$1(next)) { + if (prev !== next) { + const current = style.display; + style.cssText = next; + if ("_vod" in el) { + style.display = current; + } + } + } else { + for (const key in next) { + setStyle(style, key, next[key]); + } + if (prev && !isString$1(prev)) { + for (const key in prev) { + if (next[key] == null) { + setStyle(style, key, ""); + } + } + } + } + } + const importantRE = /\s*!important$/; + function setStyle(style, name, val) { + if (isArray(val)) { + val.forEach((v) => setStyle(style, name, v)); + } else { + if (name.startsWith("--")) { + style.setProperty(name, val); + } else { + const prefixed = autoPrefix(style, name); + if (importantRE.test(val)) { + style.setProperty(hyphenate(prefixed), val.replace(importantRE, ""), "important"); + } else { + style[prefixed] = val; + } + } + } + } + const prefixes = ["Webkit", "Moz", "ms"]; + const prefixCache = {}; + function autoPrefix(style, rawName) { + const cached = prefixCache[rawName]; + if (cached) { + return cached; + } + let name = camelize(rawName); + if (name !== "filter" && name in style) { + return prefixCache[rawName] = name; + } + name = capitalize(name); + for (let i = 0; i < prefixes.length; i++) { + const prefixed = prefixes[i] + name; + if (prefixed in style) { + return prefixCache[rawName] = prefixed; + } + } + return rawName; + } + const xlinkNS = "http://www.w3.org/1999/xlink"; + function patchAttr(el, key, value, isSVG, instance) { + if (isSVG && key.startsWith("xlink:")) { + if (value == null) { + el.removeAttributeNS(xlinkNS, key.slice(6, key.length)); + } else { + el.setAttributeNS(xlinkNS, key, value); + } + } else { + const isBoolean = isSpecialBooleanAttr(key); + if (value == null || isBoolean && value === false) { + el.removeAttribute(key); + } else { + el.setAttribute(key, isBoolean ? "" : value); + } + } + } + function patchDOMProp(el, key, value, prevChildren, parentComponent, parentSuspense, unmountChildren) { + if (key === "innerHTML" || key === "textContent") { + if (prevChildren) { + unmountChildren(prevChildren, parentComponent, parentSuspense); + } + el[key] = value == null ? "" : value; + return; + } + if (key === "value" && el.tagName !== "PROGRESS") { + el._value = value; + const newValue = value == null ? "" : value; + if (el.value !== newValue) { + el.value = newValue; + } + if (value == null) { + el.removeAttribute(key); + } + return; + } + if (value === "" || value == null) { + const type = typeof el[key]; + if (value === "" && type === "boolean") { + el[key] = true; + return; + } else if (value == null && type === "string") { + el[key] = ""; + el.removeAttribute(key); + return; + } else if (type === "number") { + el[key] = 0; + el.removeAttribute(key); + return; + } + } + try { + el[key] = value; + } catch (e) { + } + } + let _getNow = Date.now; + let skipTimestampCheck = false; + if (typeof window !== "undefined") { + if (_getNow() > document.createEvent("Event").timeStamp) { + _getNow = () => performance.now(); + } + const ffMatch = navigator.userAgent.match(/firefox\/(\d+)/i); + skipTimestampCheck = !!(ffMatch && Number(ffMatch[1]) <= 53); + } + let cachedNow = 0; + const p = Promise.resolve(); + const reset = () => { + cachedNow = 0; + }; + const getNow = () => cachedNow || (p.then(reset), cachedNow = _getNow()); + function addEventListener(el, event, handler, options) { + el.addEventListener(event, handler, options); + } + function removeEventListener(el, event, handler, options) { + el.removeEventListener(event, handler, options); + } + function patchEvent(el, rawName, prevValue, nextValue, instance = null) { + const invokers = el._vei || (el._vei = {}); + const existingInvoker = invokers[rawName]; + if (nextValue && existingInvoker) { + existingInvoker.value = nextValue; + } else { + const [name, options] = parseName(rawName); + if (nextValue) { + const invoker = invokers[rawName] = createInvoker(nextValue, instance); + addEventListener(el, name, invoker, options); + } else if (existingInvoker) { + removeEventListener(el, name, existingInvoker, options); + invokers[rawName] = void 0; + } + } + } + const optionsModifierRE = /(?:Once|Passive|Capture)$/; + function parseName(name) { + let options; + if (optionsModifierRE.test(name)) { + options = {}; + let m; + while (m = name.match(optionsModifierRE)) { + name = name.slice(0, name.length - m[0].length); + options[m[0].toLowerCase()] = true; + } + } + return [hyphenate(name.slice(2)), options]; + } + function createInvoker(initialValue, instance) { + const invoker = (e) => { + const timeStamp = e.timeStamp || _getNow(); + if (skipTimestampCheck || timeStamp >= invoker.attached - 1) { + callWithAsyncErrorHandling(patchStopImmediatePropagation(e, invoker.value), instance, 5, [e]); + } + }; + invoker.value = initialValue; + invoker.attached = getNow(); + return invoker; + } + function patchStopImmediatePropagation(e, value) { + if (isArray(value)) { + const originalStop = e.stopImmediatePropagation; + e.stopImmediatePropagation = () => { + originalStop.call(e); + e._stopped = true; + }; + return value.map((fn) => (e2) => !e2._stopped && fn(e2)); + } else { + return value; + } + } + const nativeOnRE = /^on[a-z]/; + const forcePatchProp = (_, key) => key === "value"; + const patchProp = (el, key, prevValue, nextValue, isSVG = false, prevChildren, parentComponent, parentSuspense, unmountChildren) => { + switch (key) { + case "class": + patchClass(el, nextValue, isSVG); + break; + case "style": + patchStyle(el, prevValue, nextValue); + break; + default: + if (isOn(key)) { + if (!isModelListener(key)) { + patchEvent(el, key, prevValue, nextValue, parentComponent); + } + } else if (shouldSetAsProp(el, key, nextValue, isSVG)) { + patchDOMProp(el, key, nextValue, prevChildren, parentComponent, parentSuspense, unmountChildren); + } else { + if (key === "true-value") { + el._trueValue = nextValue; + } else if (key === "false-value") { + el._falseValue = nextValue; + } + patchAttr(el, key, nextValue, isSVG); + } + break; + } + }; + function shouldSetAsProp(el, key, value, isSVG) { + if (isSVG) { + if (key === "innerHTML") { + return true; + } + if (key in el && nativeOnRE.test(key) && isFunction(value)) { + return true; + } + return false; + } + if (key === "spellcheck" || key === "draggable") { + return false; + } + if (key === "form") { + return false; + } + if (key === "list" && el.tagName === "INPUT") { + return false; + } + if (key === "type" && el.tagName === "TEXTAREA") { + return false; + } + if (nativeOnRE.test(key) && isString$1(value)) { + return false; + } + return key in el; + } + const rendererOptions = extend$1({ patchProp, forcePatchProp }, nodeOps); + let renderer; + function ensureRenderer() { + return renderer || (renderer = createRenderer(rendererOptions)); + } + const createApp = (...args) => { + const app = ensureRenderer().createApp(...args); + const { mount } = app; + app.mount = (containerOrSelector) => { + const container = normalizeContainer(containerOrSelector); + if (!container) + return; + const component = app._component; + if (!isFunction(component) && !component.render && !component.template) { + component.template = container.innerHTML; + } + container.innerHTML = ""; + const proxy = mount(container, false, container instanceof SVGElement); + if (container instanceof Element) { + container.removeAttribute("v-cloak"); + container.setAttribute("data-v-app", ""); + } + return proxy; + }; + return app; + }; + function normalizeContainer(container) { + if (isString$1(container)) { + const res = document.querySelector(container); + return res; + } + return container; + } var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof window !== "undefined" ? window : typeof self !== "undefined" ? self : {}; function getDefaultExportFromCjs(x) { return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x; } var dist = { exports: {} }; - (function(module2, exports2) { + (function(module, exports) { !function(t, e) { - module2.exports = e(); + module.exports = e(); }(typeof self != "undefined" ? self : commonjsGlobal, function() { return function(t) { var e = {}; @@ -95,7 +5043,7 @@ }, l = function(t2) { return /function Number/.test(String(t2)); }; - function p(t2, e2) { + function p2(t2, e2) { if (t2.nodeType === 3) return t2.data.trim() ? t2.data : null; if (t2.nodeType === 1) { @@ -125,9 +5073,9 @@ } } function v(t2, e2) { - return !e2 || y(e2) !== "object" && typeof e2 != "function" ? h(t2) : e2; + return !e2 || y(e2) !== "object" && typeof e2 != "function" ? h2(t2) : e2; } - function h(t2) { + function h2(t2) { if (t2 === void 0) throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); return t2; @@ -208,7 +5156,7 @@ }(this, C), (t4 = P.call(this))._wrapper = void 0, t4._component = void 0, t4._props = void 0, t4._slotChildren = void 0, t4._mounted = false; var r2 = t4.createEventProxies(_2.emits); t4._props = {}, t4._slotChildren = []; - var o3 = h(t4); + var o3 = h2(t4); return t4._wrapper = e2({ render: function() { var t5 = Object.assign({}, o3._props, r2); return delete t5.dataVApp, n2(_2, t5, function() { @@ -221,9 +5169,9 @@ } }), new MutationObserver(function(e3) { for (var n3 = 0; n3 < e3.length; n3++) { var r3 = e3[n3]; - j2 && r3.type === "attributes" && r3.target === h(t4) ? r3.attributeName && t4.syncAttribute(r3.attributeName) : true; + j2 && r3.type === "attributes" && r3.target === h2(t4) ? r3.attributeName && t4.syncAttribute(r3.attributeName) : true; } - }).observe(h(t4), { childList: true, subtree: true, characterData: true, attributes: true }), t4; + }).observe(h2(t4), { childList: true, subtree: true, characterData: true, attributes: true }), t4; } return x2 = C, (A = [{ key: "createEventProxies", value: function(t4) { var e3 = this, n3 = {}; @@ -251,7 +5199,7 @@ var t4; this._slotChildren = function(t5, e3) { for (var n3 = [], r2 = 0, o3 = t5.length; r2 < o3; r2++) - n3.push(p(t5[r2], e3)); + n3.push(p2(t5[r2], e3)); return n3; }(this.childNodes, n2), (t4 = this._component) === null || t4 === void 0 || t4.$forceUpdate(); } }, { key: "syncInitialAttributes", value: function() { @@ -658,20 +5606,20 @@ const ICON_PATH_SUCCESS = "M15.808 0.16q-4.224 0-7.872 2.176-3.552 2.112-5.632 5.728-2.144 3.744-2.144 8.128 0 4.192 2.144 7.872 2.112 3.52 5.632 5.632 3.68 2.144 7.872 2.144 4.384 0 8.128-2.144 3.616-2.080 5.728-5.632 2.176-3.648 2.176-7.872 0-4.384-2.176-8.128-2.112-3.616-5.728-5.728-3.744-2.176-8.128-2.176zM24.832 11.328l-11.264 11.104q-0.032 0.032-0.112 0.032t-0.112-0.032l-5.216-5.376q-0.096-0.128 0-0.288l0.704-0.96q0.032-0.064 0.112-0.064t0.112 0.032l4.256 3.264q0.064 0.032 0.144 0.032t0.112-0.032l10.336-8.608q0.064-0.064 0.144-0.064t0.112 0.064l0.672 0.672q0.128 0.128 0 0.224z"; const ICON_PATH_WAITING = "M15.84 0.096q-4.224 0-7.872 2.176-3.552 2.112-5.632 5.728-2.144 3.744-2.144 8.128 0 4.192 2.144 7.872 2.112 3.52 5.632 5.632 3.68 2.144 7.872 2.144 4.384 0 8.128-2.144 3.616-2.080 5.728-5.632 2.176-3.648 2.176-7.872 0-4.384-2.176-8.128-2.112-3.616-5.728-5.728-3.744-2.176-8.128-2.176zM23.008 21.92l-0.512 0.896q-0.096 0.128-0.224 0.064l-8-3.808q-0.096-0.064-0.16-0.128-0.128-0.096-0.128-0.288l0.512-12.096q0-0.064 0.048-0.112t0.112-0.048h1.376q0.064 0 0.112 0.048t0.048 0.112l0.448 10.848 6.304 4.256q0.064 0.064 0.080 0.128t-0.016 0.128z"; const ICON_PATH_WARN = "M15.808 0.16q-4.224 0-7.872 2.176-3.552 2.112-5.632 5.728-2.144 3.744-2.144 8.128 0 4.192 2.144 7.872 2.112 3.52 5.632 5.632 3.68 2.144 7.872 2.144 4.384 0 8.128-2.144 3.616-2.080 5.728-5.632 2.176-3.648 2.176-7.872 0-4.384-2.176-8.128-2.112-3.616-5.728-5.728-3.744-2.176-8.128-2.176zM15.136 8.672h1.728q0.128 0 0.224 0.096t0.096 0.256l-0.384 10.24q0 0.064-0.048 0.112t-0.112 0.048h-1.248q-0.096 0-0.144-0.048t-0.048-0.112l-0.384-10.24q0-0.16 0.096-0.256t0.224-0.096zM16 23.328q-0.48 0-0.832-0.352t-0.352-0.848 0.352-0.848 0.832-0.352 0.832 0.352 0.352 0.848-0.352 0.848-0.832 0.352z"; - function createSvgIconVNode(path, color = "#000", size = 27) { - return vue.createVNode("svg", { - width: size, - height: size, + function createSvgIconVNode(path, color = "#000", size2 = 27) { + return createVNode("svg", { + width: size2, + height: size2, viewBox: "0 0 32 32" }, [ - vue.createVNode("path", { + createVNode("path", { d: path, fill: color }, null, 8, ["d", "fill"]) ], 8, ["width", "height"]); } function useCurrentPageId() { - return vue.getCurrentInstance().root.proxy.$page.id; + return getCurrentInstance().root.proxy.$page.id; } function getRealRoute(fromRoute, toRoute) { if (toRoute.indexOf("/") === 0) { @@ -816,7 +5764,7 @@ options.compatConfig = { MODE: 3 }; - return vue.defineComponent(options); + return defineComponent(options); }; const hoverProps = { hoverClass: { @@ -837,7 +5785,7 @@ } }; function useHover(props2) { - const hovering = vue.ref(false); + const hovering = ref(false); let hoverTouch = false; let hoverStartTimer; let hoverStayTimer; @@ -904,10 +5852,10 @@ function withWebEvent(fn) { return fn.__wwe = true, fn; } - function useCustomEvent(ref, emit) { + function useCustomEvent(ref2, emit2) { return (name, evt, detail) => { - if (ref.value) { - emit(name, normalizeCustomEvent(name, evt, ref.value, detail || {})); + if (ref2.value) { + emit2(name, normalizeCustomEvent(name, evt, ref2.value, detail || {})); } }; } @@ -925,11 +5873,11 @@ const uniLabelKey = PolySymbol("uniLabel"); function useListeners(props2, listeners) { _addListeners(props2.id, listeners); - vue.watch(() => props2.id, (newId, oldId) => { + watch(() => props2.id, (newId, oldId) => { _removeListeners(oldId, listeners, true); _addListeners(newId, listeners, true); }); - vue.onUnmounted(() => { + onUnmounted(() => { _removeListeners(props2.id, listeners); }); } @@ -1020,8 +5968,8 @@ setup(props2, { slots }) { - const rootRef = vue.ref(null); - const uniForm = vue.inject(uniFormKey, false); + const rootRef = ref(null); + const uniForm = inject(uniFormKey, false); const { hovering, binding @@ -1047,10 +5995,10 @@ return; } }); - const uniLabel = vue.inject(uniLabelKey, false); + const uniLabel = inject(uniLabelKey, false); if (uniLabel) { uniLabel.addHandler(onClick); - vue.onBeforeUnmount(() => { + onBeforeUnmount(() => { uniLabel.removeHandler(onClick); }); } @@ -1062,7 +6010,7 @@ const booleanAttrs = useBooleanAttr(props2, "disabled"); const loadingAttrs = useBooleanAttr(props2, "loading"); const hasHoverClass = hoverClass && hoverClass !== "none"; - return vue.createVNode("uni-button", vue.mergeProps({ + return createVNode("uni-button", mergeProps({ "ref": rootRef, "onClick": onClick, "class": hasHoverClass && hovering.value ? hoverClass : "" @@ -1120,39 +6068,39 @@ }, emits: ["resize"], setup(props2, { - emit + emit: emit2 }) { - const rootRef = vue.ref(null); - const reset = useResizeSensorReset(rootRef); - const update = useResizeSensorUpdate(rootRef, emit, reset); - useResizeSensorLifecycle(rootRef, props2, update, reset); - return () => vue.createVNode("uni-resize-sensor", { + const rootRef = ref(null); + const reset2 = useResizeSensorReset(rootRef); + const update = useResizeSensorUpdate(rootRef, emit2, reset2); + useResizeSensorLifecycle(rootRef, props2, update, reset2); + return () => createVNode("uni-resize-sensor", { "ref": rootRef, "onAnimationstartOnce": update }, { - default: () => [vue.createVNode("div", { + default: () => [createVNode("div", { "onScroll": update - }, [vue.createVNode("div", null, null)], 40, ["onScroll"]), vue.createVNode("div", { + }, [createVNode("div", null, null)], 40, ["onScroll"]), createVNode("div", { "onScroll": update - }, [vue.createVNode("div", null, null)], 40, ["onScroll"])], + }, [createVNode("div", null, null)], 40, ["onScroll"])], _: 1 }, 8, ["onAnimationstartOnce"]); } }); - function useResizeSensorUpdate(rootRef, emit, reset) { - const size = vue.reactive({ + function useResizeSensorUpdate(rootRef, emit2, reset2) { + const size2 = reactive({ width: -1, height: -1 }); - vue.watch(() => extend({}, size), (value) => emit("resize", value)); + watch(() => extend({}, size2), (value) => emit2("resize", value)); return () => { const { width, height } = rootRef.value.getBoundingClientRect(); - size.width = width; - size.height = height; - reset(); + size2.width = width; + size2.height = height; + reset2(); }; } function useResizeSensorReset(rootRef) { @@ -1167,18 +6115,18 @@ lastElementChild.scrollTop = 1e5; }; } - function useResizeSensorLifecycle(rootRef, props2, update, reset) { - vue.onActivated(reset); - vue.onMounted(() => { + function useResizeSensorLifecycle(rootRef, props2, update, reset2) { + onActivated(reset2); + onMounted(() => { if (props2.initial) { - vue.nextTick(update); + nextTick(update); } const rootEl = rootRef.value; if (rootEl.offsetParent !== rootEl.parentElement) { rootEl.parentElement.style.position = "relative"; } if (!("AnimationEvent" in window)) { - reset(); + reset2(); } }); } @@ -1242,12 +6190,12 @@ } }, setup(props2) { - const path = vue.computed(() => ICONS[props2.type]); + const path = computed$1(() => ICONS[props2.type]); return () => { const { value } = path; - return vue.createVNode("uni-icon", null, { + return createVNode("uni-icon", null, { default: () => [value && value.d && createSvgIconVNode(value.d, props2.color || value.c, rpx2px(props2.size))] }); }; @@ -1294,16 +6242,16 @@ name: "Image", props, setup(props2, { - emit + emit: emit2 }) { - const rootRef = vue.ref(null); + const rootRef = ref(null); const state = useImageState(rootRef, props2); - const trigger = useCustomEvent(rootRef, emit); + const trigger2 = useCustomEvent(rootRef, emit2); const { fixSize } = useImageSize(rootRef, props2, state); useImageLoader(state, { - trigger, + trigger: trigger2, fixSize }); return () => { @@ -1314,41 +6262,41 @@ imgSrc, modeStyle } = state; - return vue.createVNode("uni-image", { + return createVNode("uni-image", { "ref": rootRef }, { - default: () => [vue.createVNode("div", { + default: () => [createVNode("div", { "style": modeStyle - }, null, 4), imgSrc ? vue.createVNode("img", { + }, null, 4), imgSrc ? createVNode("img", { "src": imgSrc, "draggable": props2.draggable - }, null, 8, ["src", "draggable"]) : vue.createVNode("img", null, null), FIX_MODES[mode] ? vue.createVNode(ResizeSensor, { + }, null, 8, ["src", "draggable"]) : createVNode("img", null, null), FIX_MODES[mode] ? createVNode(ResizeSensor, { "onResize": fixSize - }, null, 8, ["onResize"]) : vue.createVNode("span", null, null)], + }, null, 8, ["onResize"]) : createVNode("span", null, null)], _: 1 }, 512); }; } }); function useImageState(rootRef, props2) { - const imgSrc = vue.ref(""); - const modeStyleRef = vue.computed(() => { - let size = "auto"; + const imgSrc = ref(""); + const modeStyleRef = computed$1(() => { + let size2 = "auto"; let position = ""; const opts = IMAGE_MODES[props2.mode]; if (!opts) { position = "0% 0%"; - size = "100% 100%"; + size2 = "100% 100%"; } else { opts[0] && (position = opts[0]); - opts[1] && (size = opts[1]); + opts[1] && (size2 = opts[1]); } const srcVal = imgSrc.value; - return `background-image:${srcVal ? 'url("' + srcVal + '")' : "none"};background-position:${position};background-size:${size};background-repeat:no-repeat;`; + return `background-image:${srcVal ? 'url("' + srcVal + '")' : "none"};background-position:${position};background-size:${size2};background-repeat:no-repeat;`; }); - const state = vue.reactive({ + const state = reactive({ rootEl: rootRef, - src: vue.computed(() => props2.src ? getRealPath(props2.src) : ""), + src: computed$1(() => props2.src ? getRealPath(props2.src) : ""), origWidth: 0, origHeight: 0, origStyle: { @@ -1358,7 +6306,7 @@ modeStyle: modeStyleRef, imgSrc }); - vue.onMounted(() => { + onMounted(() => { const rootEl = rootRef.value; const style = rootEl.style; state.origWidth = Number(style.width) || 0; @@ -1367,7 +6315,7 @@ return state; } function useImageLoader(state, { - trigger, + trigger: trigger2, fixSize }) { let img; @@ -1393,7 +6341,7 @@ setState(width, height, src); fixSize(); resetImage(); - trigger("load", evt, { + trigger2("load", evt, { width, height }); @@ -1401,7 +6349,7 @@ img.onerror = (evt) => { setState(); resetImage(); - trigger("error", evt, { + trigger2("error", evt, { errMsg: `GET ${state.src} 404 (Not Found)` }); }; @@ -1414,9 +6362,9 @@ img = null; } }; - vue.watch(() => state.src, (value) => loadImage(value)); - vue.onMounted(() => loadImage(state.src)); - vue.onBeforeUnmount(() => resetImage()); + watch(() => state.src, (value) => loadImage(value)); + onMounted(() => loadImage(state.src)); + onBeforeUnmount(() => resetImage()); } const isChrome = navigator.vendor === "Google Inc."; function fixNumber(num) { @@ -1462,7 +6410,7 @@ style.width = width; style.height = height; }; - vue.watch(() => props2.mode, (value, oldValue) => { + watch(() => props2.mode, (value, oldValue) => { if (FIX_MODES[oldValue]) { resetSize(); } @@ -1476,7 +6424,7 @@ }; } function _isSlot(s) { - return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !vue.isVNode(s); + return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !isVNode(s); } const SPACE_UNICODE = { ensp: "\u2002", @@ -1526,13 +6474,13 @@ if (index === 0 && !text) ; else { - children.push(vue.createTextVNode(normalizeText(text, { + children.push(createTextVNode(normalizeText(text, { space: props2.space, decode: props2.decode }))); } if (index !== len) { - children.push(vue.createVNode("br")); + children.push(createVNode("br")); } }); } else { @@ -1543,9 +6491,9 @@ } }); } - return vue.createVNode("uni-text", { + return createVNode("uni-text", { "selectable": props2.selectable ? true : null - }, _isSlot(_slot = vue.createVNode("span", null, children)) ? _slot : { + }, _isSlot(_slot = createVNode("span", null, children)) ? _slot : { default: () => [_slot], _: 1 }, 8, ["selectable"]); @@ -1565,22 +6513,22 @@ return () => { const hoverClass = props2.hoverClass; if (hoverClass && hoverClass !== "none") { - return vue.createVNode("uni-view", vue.mergeProps({ + return createVNode("uni-view", mergeProps({ "class": hovering.value ? hoverClass : "" }, binding), { default: () => [slots.default && slots.default()] }, 16, ["class"]); } - return vue.createVNode("uni-view", null, { + return createVNode("uni-view", null, { default: () => [slots.default && slots.default()] }); }; } }); const { customElements } = window; - customElements.define("v-uni-button", wrapper(Button, vue.createApp, vue.h)); - customElements.define("v-uni-icon", wrapper(Icon, vue.createApp, vue.h)); - customElements.define("v-uni-image", wrapper(Image$1, vue.createApp, vue.h)); - customElements.define("v-uni-text", wrapper(Text, vue.createApp, vue.h)); - customElements.define("v-uni-view", wrapper(View, vue.createApp, vue.h)); + customElements.define("v-uni-button", wrapper(Button, createApp, h)); + customElements.define("v-uni-icon", wrapper(Icon, createApp, h)); + customElements.define("v-uni-image", wrapper(Image$1, createApp, h)); + customElements.define("v-uni-text", wrapper(Text, createApp, h)); + customElements.define("v-uni-view", wrapper(View, createApp, h)); }); diff --git a/packages/uni-app-plus/package.json b/packages/uni-app-plus/package.json index 94084f7f1..f7f4b707c 100644 --- a/packages/uni-app-plus/package.json +++ b/packages/uni-app-plus/package.json @@ -17,6 +17,7 @@ "url": "https://github.com/dcloudio/uni-app/issues" }, "dependencies": { + "@webcomponents/custom-elements": "^1.4.3", "vue3-webcomponent-wrapper": "^0.1.4" }, "gitHead": "56deaeb47d42e924d10282d7af418ccee6b139bf" diff --git a/packages/uni-app-plus/src/platform/index.ts b/packages/uni-app-plus/src/platform/index.ts index 9b7ac3d01..99ead4335 100644 --- a/packages/uni-app-plus/src/platform/index.ts +++ b/packages/uni-app-plus/src/platform/index.ts @@ -1,14 +1,61 @@ +import { ComponentPublicInstance } from 'vue' +import { + AddIntersectionObserverArgs, + AddMediaQueryObserverArgs, + RemoveIntersectionObserverArgs, + RemoveMediaQueryObserverArgs, + SelectorQueryNodeInfo, + SelectorQueryRequest, +} from '@dcloudio/uni-api' + export function getBaseSystemInfo() { - return {} + // TODO + return { + platform: '', + pixelRatio: 1, + windowWidth: 750, + } } export { getRealPath } from './getRealPath' -export function operateVideoPlayer() {} -export function operateMap() {} -export function requestComponentInfo() {} -export function addIntersectionObserver() {} -export function removeIntersectionObserver() {} -export function addMediaQueryObserver() {} -export function removeMediaQueryObserver() {} -export function saveImage() {} -export function getSameOriginUrl() {} +export function operateVideoPlayer( + videoId: string, + pageId: number, + type: string, + data?: unknown +) {} +export function operateMap( + id: string, + pageId: number, + type: string, + data?: unknown +) {} +export function requestComponentInfo( + page: ComponentPublicInstance, + reqs: Array, + callback: (result: Array) => void +) {} +export function addIntersectionObserver( + args: AddIntersectionObserverArgs, + pageId: number +) {} +export function removeIntersectionObserver( + args: RemoveIntersectionObserverArgs, + pageId: number +) {} +export function addMediaQueryObserver( + args: AddMediaQueryObserverArgs, + pageId: number +) {} +export function removeMediaQueryObserver( + args: RemoveMediaQueryObserverArgs, + pageId: number +) {} +export function saveImage( + base64: string, + dirname: string, + callback: (error: Error | null, tempFilePath: string) => void +) {} +export function getSameOriginUrl(url: string): Promise { + return Promise.resolve(url) +} export const TEMP_PATH = '' diff --git a/packages/uni-app-plus/src/service/api/context/createInnerAudioContext.ts b/packages/uni-app-plus/src/service/api/context/createInnerAudioContext.ts index 206d30565..1fc076d83 100644 --- a/packages/uni-app-plus/src/service/api/context/createInnerAudioContext.ts +++ b/packages/uni-app-plus/src/service/api/context/createInnerAudioContext.ts @@ -1,5 +1,4 @@ import { extend } from '@vue/shared' -import { getRealPath } from '@dcloudio/uni-platform' import { API_CREATE_INNER_AUDIO_CONTEXT, defineSyncApi, @@ -12,6 +11,8 @@ import { innerAudioContextOffEventNames, } from '@dcloudio/uni-api' +import { getRealPath } from '../../../platform/getRealPath' + type ExtendAudio = { src?: string volume?: number diff --git a/packages/uni-app-plus/src/service/api/context/getBackgroundAudioManager.ts b/packages/uni-app-plus/src/service/api/context/getBackgroundAudioManager.ts index f13b4a195..9faa2cfde 100644 --- a/packages/uni-app-plus/src/service/api/context/getBackgroundAudioManager.ts +++ b/packages/uni-app-plus/src/service/api/context/getBackgroundAudioManager.ts @@ -5,7 +5,7 @@ import { API_TYPE_GET_BACKGROUND_AUDIO_MANAGER, } from '@dcloudio/uni-api' import { once } from '@dcloudio/uni-shared' -import { getRealPath } from '@dcloudio/uni-platform' +import { getRealPath } from '../../../platform/getRealPath' type eventNames = | 'canplay' diff --git a/packages/uni-app-plus/src/service/api/file/openDocument.ts b/packages/uni-app-plus/src/service/api/file/openDocument.ts index 919a95a88..4b4a19d3a 100644 --- a/packages/uni-app-plus/src/service/api/file/openDocument.ts +++ b/packages/uni-app-plus/src/service/api/file/openDocument.ts @@ -6,7 +6,7 @@ import { OpenDocumentOptions, } from '@dcloudio/uni-api' -import { getRealPath } from '@dcloudio/uni-platform' +import { getRealPath } from '../../../platform/getRealPath' export const openDocument = defineAsyncApi( API_OPEN_DOCUMENT, ({ filePath, fileType }, { resolve, reject }) => { diff --git a/packages/uni-app-plus/src/service/api/media/previewImage.ts b/packages/uni-app-plus/src/service/api/media/previewImage.ts index 270d27858..2f5bb7f47 100644 --- a/packages/uni-app-plus/src/service/api/media/previewImage.ts +++ b/packages/uni-app-plus/src/service/api/media/previewImage.ts @@ -6,12 +6,12 @@ import { PreviewImageOptions, } from '@dcloudio/uni-api' -import { getRealPath } from '@dcloudio/uni-platform' - import { isPlainObject } from '@vue/shared' import { initI18nChooseImageMsgsOnce, useI18n } from '@dcloudio/uni-core' +import { getRealPath } from '../../../platform/getRealPath' + export const previewImage = defineAsyncApi( API_PREVIEW_IMAGE, ( diff --git a/packages/uni-app-plus/src/service/index.ts b/packages/uni-app-plus/src/service/index.ts index a330dcd8b..f0e1ae13d 100644 --- a/packages/uni-app-plus/src/service/index.ts +++ b/packages/uni-app-plus/src/service/index.ts @@ -1,6 +1,9 @@ +import * as uni from './api' import { registerApp as __registerApp } from './framework/app' import { registerPage as __registerPage } from './framework/page' +// ;(uni as any).__$wx__ = uni export default { + uni, __registerApp, __registerPage, } diff --git a/packages/uni-app-plus/src/view/index.ts b/packages/uni-app-plus/src/view/index.ts index 8658e5076..923b5326f 100644 --- a/packages/uni-app-plus/src/view/index.ts +++ b/packages/uni-app-plus/src/view/index.ts @@ -1 +1,2 @@ -import { initView } from '@dcloudio/uni-core' +import '@webcomponents/custom-elements' +import './components' diff --git a/packages/uni-app-plus/tsconfig.json b/packages/uni-app-plus/tsconfig.json new file mode 100644 index 000000000..4b74d4e5a --- /dev/null +++ b/packages/uni-app-plus/tsconfig.json @@ -0,0 +1,9 @@ +{ + "extends": "../../tsconfig.json", + "compilerOptions": { + "paths": { + "@dcloudio/*": ["packages/*/src"], + "@dcloudio/uni-platform": ["packages/uni-app-plus/src/platform/index.ts"] + } + } +} diff --git a/packages/uni-app-plus/vite.config.ts b/packages/uni-app-plus/vite.config.ts index 86d8c67e4..871efc50b 100644 --- a/packages/uni-app-plus/vite.config.ts +++ b/packages/uni-app-plus/vite.config.ts @@ -47,6 +47,10 @@ export default defineConfig({ }, resolve: { alias: [ + { + find: 'vue', + replacement: resolve('../uni-app-vue/dist/view.runtime.esm.js'), + }, { find: '@dcloudio/uni-api', replacement: resolve('../uni-api/src/index.ts'), @@ -88,21 +92,21 @@ export default defineConfig({ lib: { name: 'uni-app-view', fileName: 'uni-app-view', - entry: path.resolve(__dirname, 'src/view/components/index.ts'), + entry: path.resolve(__dirname, 'src/view/index.ts'), formats: ['umd'], }, assetsDir: '.', rollupOptions: { - output: { - globals: { - vue: 'Vue', - }, - }, - external(source) { - if (['vue'].includes(source)) { - return true - } - }, + // output: { + // globals: { + // vue: 'Vue', + // }, + // }, + // external(source) { + // if (['vue'].includes(source)) { + // return true + // } + // }, preserveEntrySignatures: 'strict', plugins: rollupPlugins, onwarn: (msg, warn) => { diff --git a/packages/uni-app-vue/build.json b/packages/uni-app-vue/build.json index b8ffbc363..5268ae662 100644 --- a/packages/uni-app-vue/build.json +++ b/packages/uni-app-vue/build.json @@ -1,10 +1,18 @@ -{ - "input": { - "src/index.ts": ["dist/vue.runtime.esm.js"] +[ + { + "input": { + "src/service/index.ts": ["dist/service.runtime.esm.js"] + }, + "output": { + "banner": "export default function vueFactory (exports) {\n", + "footer": "}" + }, + "external": false }, - "output": { - "banner": "export default function vueFactory (exports) {\n", - "footer": "}" - }, - "external": false -} + { + "input": { + "src/view/index.ts": ["dist/view.runtime.esm.js"] + }, + "external": false + } +] diff --git a/packages/uni-app-vue/dist/service.runtime.esm.js b/packages/uni-app-vue/dist/service.runtime.esm.js new file mode 100644 index 000000000..4998a4f0b --- /dev/null +++ b/packages/uni-app-vue/dist/service.runtime.esm.js @@ -0,0 +1,10026 @@ +export default function vueFactory (exports) { + +/** + * Make a map and return a function for checking if a key + * is in that map. + * IMPORTANT: all calls of this function must be prefixed with + * \/\*#\_\_PURE\_\_\*\/ + * So that rollup can tree-shake them if necessary. + */ +(process.env.NODE_ENV !== 'production') + ? Object.freeze({}) + : {}; +(process.env.NODE_ENV !== 'production') ? Object.freeze([]) : []; +const extend$1 = Object.assign; +const cacheStringFunction$1 = (fn) => { + const cache = Object.create(null); + return ((str) => { + const hit = cache[str]; + return hit || (cache[str] = fn(str)); + }); +}; +const camelizeRE$1 = /-(\w)/g; +/** + * @private + */ +const camelize$1 = cacheStringFunction$1((str) => { + return str.replace(camelizeRE$1, (_, c) => (c ? c.toUpperCase() : '')); +}); +/** + * @private + */ +const capitalize$1 = cacheStringFunction$1((str) => str.charAt(0).toUpperCase() + str.slice(1)); + +class DOMException extends Error { + constructor(message) { + super(message); + this.name = 'DOMException'; + } +} + +function normalizeEventType(type) { + return `on${capitalize$1(camelize$1(type))}`; +} +class UniEventTarget { + constructor() { + this._listeners = {}; + } + dispatchEvent(evt) { + const listeners = this._listeners[evt.type]; + if (!listeners) { + return false; + } + const len = listeners.length; + for (let i = 0; i < len; i++) { + listeners[i].call(this, evt); + if (evt._end) { + break; + } + } + return evt.cancelable && evt.defaultPrevented; + } + addEventListener(type, listener, options) { + const isOnce = options && options.once; + if (isOnce) { + const wrapper = function (evt) { + listener.apply(this, [evt]); + this.removeEventListener(type, wrapper, options); + }; + return this.addEventListener(type, wrapper, extend$1(options, { once: false })); + } + (this._listeners[type] || (this._listeners[type] = [])).push(listener); + } + removeEventListener(type, callback, options) { + const listeners = this._listeners[type.toLowerCase()]; + if (!listeners) { + return; + } + const index = listeners.indexOf(callback); + if (index > -1) { + listeners.splice(index, 1); + } + } +} + +class UniCSSStyleDeclaration { + constructor() { + this._cssText = null; + this._value = null; + } + setProperty(property, value) { + if (value === null || value === '') { + this.removeProperty(property); + } + else { + if (!this._value) { + this._value = {}; + } + this._value[property] = value; + } + } + getPropertyValue(property) { + if (!this._value) { + return ''; + } + return this._value[property] || ''; + } + removeProperty(property) { + if (!this._value) { + return ''; + } + const value = this._value[property]; + delete this._value[property]; + return value; + } + get cssText() { + return this._cssText || ''; + } + set cssText(cssText) { + this._cssText = cssText; + } + toJSON() { + const { _cssText, _value } = this; + const hasCssText = _cssText !== null; + const hasValue = _value !== null; + if (hasCssText && hasValue) { + return [_cssText, _value]; + } + if (hasCssText) { + return _cssText; + } + if (hasValue) { + return _value; + } + } +} +const STYLE_PROPS = [ + '_value', + '_cssText', + 'cssText', + 'getPropertyValue', + 'setProperty', + 'removeProperty', + 'toJSON', +]; +function proxyStyle(uniCssStyle) { + return new Proxy(uniCssStyle, { + get(target, key, receiver) { + if (STYLE_PROPS.indexOf(key) === -1) { + return target.getPropertyValue(key); + } + return Reflect.get(target, key, receiver); + }, + set(target, key, value, receiver) { + if (STYLE_PROPS.indexOf(key) === -1) { + target.setProperty(key, value); + return true; + } + return Reflect.set(target, key, value, receiver); + }, + }); +} + +const ATTR_MAP = { + class: '.c', + style: '.s', + onClick: '.e0', + onChange: '.e1', + onInput: '.e2', + onLoad: '.e3', + onError: '.e4', + onTouchstart: '.e5', + onTouchmove: '.e6', + onTouchcancel: '.e7', + onTouchend: '.e8', + onLongpress: '.e9', + onTransitionend: '.ea', + onAnimationstart: '.eb', + onAnimationiteration: '.ec', + onAnimationend: '.ed', + onTouchforcechange: '.ee', +}; +function encodeAttr(name) { + return ATTR_MAP[name] || name; +} +const COMPONENT_MAP = { + VIEW: 1, + IMAGE: 2, + TEXT: 3, + '#text': 4, + '#comment': 5, + NAVIGATOR: 6, + FORM: 7, + BUTTON: 8, + INPUT: 9, + LABEL: 10, + RADIO: 11, + CHECKBOX: 12, + 'CHECKBOX-GROUP': 13, + AD: 14, + AUDIO: 15, + CAMERA: 16, + CANVAS: 17, + 'COVER-IMAGE': 18, + 'COVER-VIEW': 19, + EDITOR: 20, + 'FUNCTIONAL-PAGE-NAVIGATOR': 21, + ICON: 22, + 'RADIO-GROUP': 23, + 'LIVE-PLAYER': 24, + 'LIVE-PUSHER': 25, + MAP: 26, + 'MOVABLE-AREA': 27, + 'MOVABLE-VIEW': 28, + 'OFFICIAL-ACCOUNT': 29, + 'OPEN-DATA': 30, + PICKER: 31, + 'PICKER-VIEW': 32, + 'PICKER-VIEW-COLUMN': 33, + PROGRESS: 34, + 'RICH-TEXT': 35, + 'SCROLL-VIEW': 36, + SLIDER: 37, + SWIPER: 38, + 'SWIPER-ITEM': 39, + SWITCH: 40, + TEXTAREA: 41, + VIDEO: 42, + 'WEB-VIEW': 43, +}; +function encodeTag(tag) { + return COMPONENT_MAP[tag] || tag; +} + +const NODE_TYPE_PAGE = 0; +const NODE_TYPE_ELEMENT = 1; +const NODE_TYPE_TEXT = 3; +const NODE_TYPE_COMMENT = 8; +function sibling(node, type) { + const { parentNode } = node; + if (!parentNode) { + return null; + } + const { childNodes } = parentNode; + return childNodes[childNodes.indexOf(node) + (type === 'n' ? 1 : -1)] || null; +} +function removeNode(node) { + const { parentNode } = node; + if (parentNode) { + parentNode.removeChild(node); + } +} +function checkNodeId(node) { + if (!node.nodeId) { + node.nodeId = node.pageNode.genId(); + } +} +// 为优化性能，各平台不使用proxy来实现node的操作拦截，而是直接通过pageNode定制 +class UniNode extends UniEventTarget { + constructor(nodeType, nodeName, container) { + super(); + this.pageNode = null; + this.parentNode = null; + this._text = null; + if (container) { + const { pageNode } = container; + this.pageNode = pageNode; + this.nodeId = pageNode.genId(); + pageNode.onCreate(this, encodeTag(nodeName)); + } + this.nodeType = nodeType; + this.nodeName = nodeName; + this.childNodes = []; + } + get firstChild() { + return this.childNodes[0] || null; + } + get lastChild() { + const { childNodes } = this; + const length = childNodes.length; + return length ? childNodes[length - 1] : null; + } + get nextSibling() { + return sibling(this, 'n'); + } + get nodeValue() { + return null; + } + set nodeValue(_val) { } + get textContent() { + return this._text || ''; + } + set textContent(text) { + this._text = text; + if (this.pageNode) { + this.pageNode.onTextContent(this, text); + } + } + get parentElement() { + const { parentNode } = this; + if (parentNode && parentNode.nodeType === NODE_TYPE_ELEMENT) { + return parentNode; + } + return null; + } + get previousSibling() { + return sibling(this, 'p'); + } + appendChild(newChild) { + return this.insertBefore(newChild, null); + } + cloneNode(deep) { + const cloned = extend$1(Object.create(Object.getPrototypeOf(this)), this); + const { attributes } = cloned; + if (attributes) { + cloned.attributes = extend$1({}, attributes); + } + if (deep) { + cloned.childNodes = cloned.childNodes.map((childNode) => childNode.cloneNode(true)); + } + return cloned; + } + insertBefore(newChild, refChild) { + removeNode(newChild); + newChild.pageNode = this.pageNode; + newChild.parentNode = this; + checkNodeId(newChild); + const { childNodes } = this; + let index; + if (refChild) { + index = childNodes.indexOf(refChild); + if (index === -1) { + throw new DOMException(`Failed to execute 'insertBefore' on 'Node': The node before which the new node is to be inserted is not a child of this node.`); + } + childNodes.splice(index, 0, newChild); + } + else { + index = childNodes.length; + childNodes.push(newChild); + } + return this.pageNode + ? this.pageNode.onInsertBefore(this, newChild, index) + : newChild; + } + removeChild(oldChild) { + const { childNodes } = this; + const index = childNodes.indexOf(oldChild); + if (index === -1) { + throw new DOMException(`Failed to execute 'removeChild' on 'Node': The node to be removed is not a child of this node.`); + } + oldChild.parentNode = null; + childNodes.splice(index, 1); + return this.pageNode + ? this.pageNode.onRemoveChild(this, oldChild) + : oldChild; + } +} +class UniBaseNode extends UniNode { + constructor(nodeType, nodeName, container) { + super(nodeType, nodeName, container); + this.attributes = Object.create(null); + this._html = null; + this.style = proxyStyle(new UniCSSStyleDeclaration()); + } + get className() { + return (this.attributes['class'] || ''); + } + set className(val) { + this.setAttribute('class', val); + } + get innerHTML() { + return ''; + } + set innerHTML(html) { + this._html = html; + } + addEventListener(type, listener, options) { + super.addEventListener(type, listener, options); + const normalized = normalizeEventType(type); + if (!this.attributes[normalized]) { + this.setAttribute(normalized, 1); + } + } + removeEventListener(type, callback, options) { + super.removeEventListener(type, callback, options); + const normalized = normalizeEventType(type); + if (this.attributes[encodeAttr(normalized)]) { + this.removeAttribute(normalized); + } + } + getAttribute(qualifiedName) { + return this.attributes[encodeAttr(qualifiedName)]; + } + removeAttribute(qualifiedName) { + qualifiedName = encodeAttr(qualifiedName); + delete this.attributes[qualifiedName]; + if (this.pageNode) { + this.pageNode.onRemoveAttribute(this, qualifiedName); + } + } + setAttribute(qualifiedName, value) { + qualifiedName = encodeAttr(qualifiedName); + this.attributes[qualifiedName] = value; + if (this.pageNode) { + this.pageNode.onSetAttribute(this, qualifiedName, value); + } + } + toJSON(opts = {}) { + const res = { + a: this.attributes, + s: this.style.toJSON(), + }; + if (!opts.attr) { + res.i = this.nodeId; + res.n = encodeTag(this.nodeName); + } + if (this._text !== null) { + res.t = this._text; + } + return res; + } +} + +class UniCommentNode extends UniNode { + constructor(text, container) { + super(NODE_TYPE_COMMENT, '#comment', container); + this._text = text; + } + toJSON(opts = {}) { + return opts.attr + ? { t: this._text } + : { + i: this.nodeId, + t: this._text, + }; + } +} + +class UniElement extends UniBaseNode { + constructor(nodeName, container) { + super(NODE_TYPE_ELEMENT, nodeName.toUpperCase(), container); + this.tagName = this.nodeName; + } +} + +class UniTextNode extends UniBaseNode { + constructor(text, container) { + super(NODE_TYPE_TEXT, '#text', container); + this._text = text; + } + get nodeValue() { + return this._text || ''; + } + set nodeValue(text) { + this._text = text; + if (this.pageNode) { + this.pageNode.onNodeValue(this, text); + } + } +} +const DECODED_COMPONENT_ARR = /*#__PURE__*/ Object.keys(COMPONENT_MAP).reduce((arr, name) => { + arr.push(name.toLowerCase()); + return arr; +}, ['']); +function decodeTag(tag) { + return DECODED_COMPONENT_ARR[tag] || tag; +} + +/** + * Make a map and return a function for checking if a key + * is in that map. + * IMPORTANT: all calls of this function must be prefixed with + * \/\*#\_\_PURE\_\_\*\/ + * So that rollup can tree-shake them if necessary. + */ +function makeMap(str, expectsLowerCase) { + const map = Object.create(null); + const list = str.split(','); + for (let i = 0; i < list.length; i++) { + map[list[i]] = true; + } + return expectsLowerCase ? val => !!map[val.toLowerCase()] : val => !!map[val]; +} + +const GLOBALS_WHITE_LISTED = 'Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,' + + 'decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,' + + 'Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt'; +const isGloballyWhitelisted = /*#__PURE__*/ makeMap(GLOBALS_WHITE_LISTED); + +function normalizeStyle(value) { + if (isArray(value)) { + const res = {}; + for (let i = 0; i < value.length; i++) { + const item = value[i]; + const normalized = normalizeStyle(isString(item) ? parseStringStyle(item) : item); + if (normalized) { + for (const key in normalized) { + res[key] = normalized[key]; + } + } + } + return res; + } + else if (isObject(value)) { + return value; + } +} +const listDelimiterRE = /;(?![^(]*\))/g; +const propertyDelimiterRE = /:(.+)/; +function parseStringStyle(cssText) { + const ret = {}; + cssText.split(listDelimiterRE).forEach(item => { + if (item) { + const tmp = item.split(propertyDelimiterRE); + tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim()); + } + }); + return ret; +} +function normalizeClass(value) { + let res = ''; + if (isString(value)) { + res = value; + } + else if (isArray(value)) { + for (let i = 0; i < value.length; i++) { + const normalized = normalizeClass(value[i]); + if (normalized) { + res += normalized + ' '; + } + } + } + else if (isObject(value)) { + for (const name in value) { + if (value[name]) { + res += name + ' '; + } + } + } + return res.trim(); +} + +// These tag configs are shared between compiler-dom and runtime-dom, so they +// https://developer.mozilla.org/en-US/docs/Web/HTML/Element +const HTML_TAGS = 'html,body,base,head,link,meta,style,title,address,article,aside,footer,' + + 'header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,' + + 'figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,' + + 'data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,' + + 'time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,' + + 'canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,' + + 'th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,' + + 'option,output,progress,select,textarea,details,dialog,menu,' + + 'summary,template,blockquote,iframe,tfoot'; +// https://developer.mozilla.org/en-US/docs/Web/SVG/Element +const SVG_TAGS = 'svg,animate,animateMotion,animateTransform,circle,clipPath,color-profile,' + + 'defs,desc,discard,ellipse,feBlend,feColorMatrix,feComponentTransfer,' + + 'feComposite,feConvolveMatrix,feDiffuseLighting,feDisplacementMap,' + + 'feDistanceLight,feDropShadow,feFlood,feFuncA,feFuncB,feFuncG,feFuncR,' + + 'feGaussianBlur,feImage,feMerge,feMergeNode,feMorphology,feOffset,' + + 'fePointLight,feSpecularLighting,feSpotLight,feTile,feTurbulence,filter,' + + 'foreignObject,g,hatch,hatchpath,image,line,linearGradient,marker,mask,' + + 'mesh,meshgradient,meshpatch,meshrow,metadata,mpath,path,pattern,' + + 'polygon,polyline,radialGradient,rect,set,solidcolor,stop,switch,symbol,' + + 'text,textPath,title,tspan,unknown,use,view'; +const isHTMLTag = /*#__PURE__*/ makeMap(HTML_TAGS); +const isSVGTag = /*#__PURE__*/ makeMap(SVG_TAGS); + +/** + * For converting {{ interpolation }} values to displayed strings. + * @private + */ +const toDisplayString = (val) => { + return val == null + ? '' + : isObject(val) + ? JSON.stringify(val, replacer, 2) + : String(val); +}; +const replacer = (_key, val) => { + if (isMap(val)) { + return { + [`Map(${val.size})`]: [...val.entries()].reduce((entries, [key, val]) => { + entries[`${key} =>`] = val; + return entries; + }, {}) + }; + } + else if (isSet(val)) { + return { + [`Set(${val.size})`]: [...val.values()] + }; + } + else if (isObject(val) && !isArray(val) && !isPlainObject(val)) { + return String(val); + } + return val; +}; + +const EMPTY_OBJ = (process.env.NODE_ENV !== 'production') + ? Object.freeze({}) + : {}; +const EMPTY_ARR = (process.env.NODE_ENV !== 'production') ? Object.freeze([]) : []; +const NOOP = () => { }; +/** + * Always return false. + */ +const NO = () => false; +const onRE = /^on[^a-z]/; +const isOn = (key) => onRE.test(key); +const isModelListener = (key) => key.startsWith('onUpdate:'); +const extend = Object.assign; +const remove = (arr, el) => { + const i = arr.indexOf(el); + if (i > -1) { + arr.splice(i, 1); + } +}; +const hasOwnProperty = Object.prototype.hasOwnProperty; +const hasOwn = (val, key) => hasOwnProperty.call(val, key); +const isArray = Array.isArray; +const isMap = (val) => toTypeString(val) === '[object Map]'; +const isSet = (val) => toTypeString(val) === '[object Set]'; +const isFunction = (val) => typeof val === 'function'; +const isString = (val) => typeof val === 'string'; +const isSymbol = (val) => typeof val === 'symbol'; +const isObject = (val) => val !== null && typeof val === 'object'; +const isPromise = (val) => { + return isObject(val) && isFunction(val.then) && isFunction(val.catch); +}; +const objectToString = Object.prototype.toString; +const toTypeString = (value) => objectToString.call(value); +const toRawType = (value) => { + // extract "RawType" from strings like "[object RawType]" + return toTypeString(value).slice(8, -1); +}; +const isPlainObject = (val) => toTypeString(val) === '[object Object]'; +const isIntegerKey = (key) => isString(key) && + key !== 'NaN' && + key[0] !== '-' && + '' + parseInt(key, 10) === key; +const isReservedProp = /*#__PURE__*/ makeMap( +// the leading comma is intentional so empty string "" is also included +',key,ref,' + + 'onVnodeBeforeMount,onVnodeMounted,' + + 'onVnodeBeforeUpdate,onVnodeUpdated,' + + 'onVnodeBeforeUnmount,onVnodeUnmounted'); +const cacheStringFunction = (fn) => { + const cache = Object.create(null); + return ((str) => { + const hit = cache[str]; + return hit || (cache[str] = fn(str)); + }); +}; +const camelizeRE = /-(\w)/g; +/** + * @private + */ +const camelize = cacheStringFunction((str) => { + return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : '')); +}); +const hyphenateRE = /\B([A-Z])/g; +/** + * @private + */ +const hyphenate = cacheStringFunction((str) => str.replace(hyphenateRE, '-$1').toLowerCase()); +/** + * @private + */ +const capitalize = cacheStringFunction((str) => str.charAt(0).toUpperCase() + str.slice(1)); +/** + * @private + */ +const toHandlerKey = cacheStringFunction((str) => (str ? `on${capitalize(str)}` : ``)); +// compare whether a value has changed, accounting for NaN. +const hasChanged = (value, oldValue) => value !== oldValue && (value === value || oldValue === oldValue); +const invokeArrayFns = (fns, arg) => { + for (let i = 0; i < fns.length; i++) { + fns[i](arg); + } +}; +const def = (obj, key, value) => { + Object.defineProperty(obj, key, { + configurable: true, + enumerable: false, + value + }); +}; +const toNumber = (val) => { + const n = parseFloat(val); + return isNaN(n) ? val : n; +}; +let _globalThis; +const getGlobalThis = () => { + return (_globalThis || + (_globalThis = + typeof globalThis !== 'undefined' + ? globalThis + : typeof self !== 'undefined' + ? self + : typeof window !== 'undefined' + ? window + : typeof window !== 'undefined' + ? window + : {})); +}; + +const targetMap = new WeakMap(); +const effectStack = []; +let activeEffect; +const ITERATE_KEY = Symbol((process.env.NODE_ENV !== 'production') ? 'iterate' : ''); +const MAP_KEY_ITERATE_KEY = Symbol((process.env.NODE_ENV !== 'production') ? 'Map key iterate' : ''); +function isEffect(fn) { + return fn && fn._isEffect === true; +} +function effect(fn, options = EMPTY_OBJ) { + if (isEffect(fn)) { + fn = fn.raw; + } + const effect = createReactiveEffect(fn, options); + if (!options.lazy) { + effect(); + } + return effect; +} +function stop(effect) { + if (effect.active) { + cleanup(effect); + if (effect.options.onStop) { + effect.options.onStop(); + } + effect.active = false; + } +} +let uid = 0; +function createReactiveEffect(fn, options) { + const effect = function reactiveEffect() { + if (!effect.active) { + return fn(); + } + if (!effectStack.includes(effect)) { + cleanup(effect); + try { + enableTracking(); + effectStack.push(effect); + activeEffect = effect; + return fn(); + } + finally { + effectStack.pop(); + resetTracking(); + activeEffect = effectStack[effectStack.length - 1]; + } + } + }; + effect.id = uid++; + effect.allowRecurse = !!options.allowRecurse; + effect._isEffect = true; + effect.active = true; + effect.raw = fn; + effect.deps = []; + effect.options = options; + return effect; +} +function cleanup(effect) { + const { deps } = effect; + if (deps.length) { + for (let i = 0; i < deps.length; i++) { + deps[i].delete(effect); + } + deps.length = 0; + } +} +let shouldTrack = true; +const trackStack = []; +function pauseTracking() { + trackStack.push(shouldTrack); + shouldTrack = false; +} +function enableTracking() { + trackStack.push(shouldTrack); + shouldTrack = true; +} +function resetTracking() { + const last = trackStack.pop(); + shouldTrack = last === undefined ? true : last; +} +function track(target, type, key) { + if (!shouldTrack || activeEffect === undefined) { + return; + } + let depsMap = targetMap.get(target); + if (!depsMap) { + targetMap.set(target, (depsMap = new Map())); + } + let dep = depsMap.get(key); + if (!dep) { + depsMap.set(key, (dep = new Set())); + } + if (!dep.has(activeEffect)) { + dep.add(activeEffect); + activeEffect.deps.push(dep); + if ((process.env.NODE_ENV !== 'production') && activeEffect.options.onTrack) { + activeEffect.options.onTrack({ + effect: activeEffect, + target, + type, + key + }); + } + } +} +function trigger(target, type, key, newValue, oldValue, oldTarget) { + const depsMap = targetMap.get(target); + if (!depsMap) { + // never been tracked + return; + } + const effects = new Set(); + const add = (effectsToAdd) => { + if (effectsToAdd) { + effectsToAdd.forEach(effect => { + if (effect !== activeEffect || effect.allowRecurse) { + effects.add(effect); + } + }); + } + }; + if (type === "clear" /* CLEAR */) { + // collection being cleared + // trigger all effects for target + depsMap.forEach(add); + } + else if (key === 'length' && isArray(target)) { + depsMap.forEach((dep, key) => { + if (key === 'length' || key >= newValue) { + add(dep); + } + }); + } + else { + // schedule runs for SET | ADD | DELETE + if (key !== void 0) { + add(depsMap.get(key)); + } + // also run for iteration key on ADD | DELETE | Map.SET + switch (type) { + case "add" /* ADD */: + if (!isArray(target)) { + add(depsMap.get(ITERATE_KEY)); + if (isMap(target)) { + add(depsMap.get(MAP_KEY_ITERATE_KEY)); + } + } + else if (isIntegerKey(key)) { + // new index added to array -> length changes + add(depsMap.get('length')); + } + break; + case "delete" /* DELETE */: + if (!isArray(target)) { + add(depsMap.get(ITERATE_KEY)); + if (isMap(target)) { + add(depsMap.get(MAP_KEY_ITERATE_KEY)); + } + } + break; + case "set" /* SET */: + if (isMap(target)) { + add(depsMap.get(ITERATE_KEY)); + } + break; + } + } + const run = (effect) => { + if ((process.env.NODE_ENV !== 'production') && effect.options.onTrigger) { + effect.options.onTrigger({ + effect, + target, + key, + type, + newValue, + oldValue, + oldTarget + }); + } + if (effect.options.scheduler) { + effect.options.scheduler(effect); + } + else { + effect(); + } + }; + effects.forEach(run); +} + +const isNonTrackableKeys = /*#__PURE__*/ makeMap(`__proto__,__v_isRef,__isVue`); +const builtInSymbols = new Set(Object.getOwnPropertyNames(Symbol) + .map(key => Symbol[key]) + .filter(isSymbol)); +const get = /*#__PURE__*/ createGetter(); +const shallowGet = /*#__PURE__*/ createGetter(false, true); +const readonlyGet = /*#__PURE__*/ createGetter(true); +const shallowReadonlyGet = /*#__PURE__*/ createGetter(true, true); +const arrayInstrumentations = {}; +['includes', 'indexOf', 'lastIndexOf'].forEach(key => { + const method = Array.prototype[key]; + arrayInstrumentations[key] = function (...args) { + const arr = toRaw(this); + for (let i = 0, l = this.length; i < l; i++) { + track(arr, "get" /* GET */, i + ''); + } + // we run the method using the original args first (which may be reactive) + const res = method.apply(arr, args); + if (res === -1 || res === false) { + // if that didn't work, run it again using raw values. + return method.apply(arr, args.map(toRaw)); + } + else { + return res; + } + }; +}); +['push', 'pop', 'shift', 'unshift', 'splice'].forEach(key => { + const method = Array.prototype[key]; + arrayInstrumentations[key] = function (...args) { + pauseTracking(); + const res = method.apply(this, args); + resetTracking(); + return res; + }; +}); +function createGetter(isReadonly = false, shallow = false) { + return function get(target, key, receiver) { + if (key === "__v_isReactive" /* IS_REACTIVE */) { + return !isReadonly; + } + else if (key === "__v_isReadonly" /* IS_READONLY */) { + return isReadonly; + } + else if (key === "__v_raw" /* RAW */ && + receiver === + (isReadonly + ? shallow + ? shallowReadonlyMap + : readonlyMap + : shallow + ? shallowReactiveMap + : reactiveMap).get(target)) { + return target; + } + const targetIsArray = isArray(target); + if (!isReadonly && targetIsArray && hasOwn(arrayInstrumentations, key)) { + return Reflect.get(arrayInstrumentations, key, receiver); + } + const res = Reflect.get(target, key, receiver); + if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) { + return res; + } + if (!isReadonly) { + track(target, "get" /* GET */, key); + } + if (shallow) { + return res; + } + if (isRef(res)) { + // ref unwrapping - does not apply for Array + integer key. + const shouldUnwrap = !targetIsArray || !isIntegerKey(key); + return shouldUnwrap ? res.value : res; + } + if (isObject(res)) { + // Convert returned value into a proxy as well. we do the isObject check + // here to avoid invalid value warning. Also need to lazy access readonly + // and reactive here to avoid circular dependency. + return isReadonly ? readonly(res) : reactive(res); + } + return res; + }; +} +const set = /*#__PURE__*/ createSetter(); +const shallowSet = /*#__PURE__*/ createSetter(true); +function createSetter(shallow = false) { + return function set(target, key, value, receiver) { + let oldValue = target[key]; + if (!shallow) { + value = toRaw(value); + oldValue = toRaw(oldValue); + if (!isArray(target) && isRef(oldValue) && !isRef(value)) { + 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); + // don't trigger if target is something up in the prototype chain of original + if (target === toRaw(receiver)) { + if (!hadKey) { + trigger(target, "add" /* ADD */, key, value); + } + else if (hasChanged(value, oldValue)) { + trigger(target, "set" /* SET */, key, value, oldValue); + } + } + return result; + }; +} +function deleteProperty(target, key) { + const hadKey = hasOwn(target, key); + const oldValue = target[key]; + const result = Reflect.deleteProperty(target, key); + if (result && hadKey) { + trigger(target, "delete" /* DELETE */, key, undefined, oldValue); + } + return result; +} +function has(target, key) { + const result = Reflect.has(target, key); + if (!isSymbol(key) || !builtInSymbols.has(key)) { + track(target, "has" /* HAS */, key); + } + return result; +} +function ownKeys(target) { + track(target, "iterate" /* ITERATE */, isArray(target) ? 'length' : ITERATE_KEY); + return Reflect.ownKeys(target); +} +const mutableHandlers = { + get, + set, + deleteProperty, + has, + ownKeys +}; +const readonlyHandlers = { + get: readonlyGet, + set(target, key) { + if ((process.env.NODE_ENV !== 'production')) { + console.warn(`Set operation on key "${String(key)}" failed: target is readonly.`, target); + } + return true; + }, + deleteProperty(target, key) { + if ((process.env.NODE_ENV !== 'production')) { + console.warn(`Delete operation on key "${String(key)}" failed: target is readonly.`, target); + } + return true; + } +}; +const shallowReactiveHandlers = extend({}, mutableHandlers, { + get: shallowGet, + set: shallowSet +}); +// Props handlers are special in the sense that it should not unwrap top-level +// refs (in order to allow refs to be explicitly passed down), but should +// retain the reactivity of the normal readonly object. +const shallowReadonlyHandlers = extend({}, readonlyHandlers, { + get: shallowReadonlyGet +}); + +const toReactive = (value) => isObject(value) ? reactive(value) : value; +const toReadonly = (value) => isObject(value) ? readonly(value) : value; +const toShallow = (value) => value; +const getProto = (v) => Reflect.getPrototypeOf(v); +function get$1(target, key, isReadonly = false, isShallow = false) { + // #1772: readonly(reactive(Map)) should return readonly + reactive version + // of the value + target = target["__v_raw" /* RAW */]; + const rawTarget = toRaw(target); + const rawKey = toRaw(key); + if (key !== rawKey) { + !isReadonly && track(rawTarget, "get" /* GET */, key); + } + !isReadonly && track(rawTarget, "get" /* GET */, rawKey); + const { has } = getProto(rawTarget); + const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive; + if (has.call(rawTarget, key)) { + return wrap(target.get(key)); + } + else if (has.call(rawTarget, rawKey)) { + return wrap(target.get(rawKey)); + } + else if (target !== rawTarget) { + // #3602 readonly(reactive(Map)) + // ensure that the nested reactive `Map` can do tracking for itself + target.get(key); + } +} +function has$1(key, isReadonly = false) { + const target = this["__v_raw" /* RAW */]; + const rawTarget = toRaw(target); + const rawKey = toRaw(key); + if (key !== rawKey) { + !isReadonly && track(rawTarget, "has" /* HAS */, key); + } + !isReadonly && track(rawTarget, "has" /* HAS */, rawKey); + return key === rawKey + ? target.has(key) + : target.has(key) || target.has(rawKey); +} +function size(target, isReadonly = false) { + target = target["__v_raw" /* RAW */]; + !isReadonly && track(toRaw(target), "iterate" /* ITERATE */, ITERATE_KEY); + return Reflect.get(target, 'size', target); +} +function add(value) { + value = toRaw(value); + const target = toRaw(this); + const proto = getProto(target); + const hadKey = proto.has.call(target, value); + if (!hadKey) { + target.add(value); + trigger(target, "add" /* ADD */, value, value); + } + return this; +} +function set$1(key, value) { + value = toRaw(value); + const target = toRaw(this); + const { has, get } = getProto(target); + let hadKey = has.call(target, key); + if (!hadKey) { + key = toRaw(key); + hadKey = has.call(target, key); + } + else if ((process.env.NODE_ENV !== 'production')) { + checkIdentityKeys(target, has, key); + } + const oldValue = get.call(target, key); + target.set(key, value); + if (!hadKey) { + trigger(target, "add" /* ADD */, key, value); + } + else if (hasChanged(value, oldValue)) { + trigger(target, "set" /* SET */, key, value, oldValue); + } + return this; +} +function deleteEntry(key) { + const target = toRaw(this); + const { has, get } = getProto(target); + let hadKey = has.call(target, key); + if (!hadKey) { + key = toRaw(key); + hadKey = has.call(target, key); + } + else if ((process.env.NODE_ENV !== 'production')) { + checkIdentityKeys(target, has, key); + } + const oldValue = get ? get.call(target, key) : undefined; + // forward the operation before queueing reactions + const result = target.delete(key); + if (hadKey) { + trigger(target, "delete" /* DELETE */, key, undefined, oldValue); + } + return result; +} +function clear() { + const target = toRaw(this); + const hadItems = target.size !== 0; + const oldTarget = (process.env.NODE_ENV !== 'production') + ? isMap(target) + ? new Map(target) + : new Set(target) + : undefined; + // forward the operation before queueing reactions + const result = target.clear(); + if (hadItems) { + trigger(target, "clear" /* CLEAR */, undefined, undefined, oldTarget); + } + return result; +} +function createForEach(isReadonly, isShallow) { + return function forEach(callback, thisArg) { + const observed = this; + const target = observed["__v_raw" /* RAW */]; + const rawTarget = toRaw(target); + const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive; + !isReadonly && track(rawTarget, "iterate" /* ITERATE */, ITERATE_KEY); + return target.forEach((value, key) => { + // important: make sure the callback is + // 1. invoked with the reactive map as `this` and 3rd arg + // 2. the value received should be a corresponding reactive/readonly. + return callback.call(thisArg, wrap(value), wrap(key), observed); + }); + }; +} +function createIterableMethod(method, isReadonly, isShallow) { + return function (...args) { + const target = this["__v_raw" /* RAW */]; + const rawTarget = toRaw(target); + const targetIsMap = isMap(rawTarget); + const isPair = method === 'entries' || (method === Symbol.iterator && targetIsMap); + const isKeyOnly = method === 'keys' && targetIsMap; + const innerIterator = target[method](...args); + const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive; + !isReadonly && + track(rawTarget, "iterate" /* ITERATE */, isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY); + // return a wrapped iterator which returns observed versions of the + // values emitted from the real iterator + 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(type) { + return function (...args) { + if ((process.env.NODE_ENV !== 'production')) { + const key = args[0] ? `on key "${args[0]}" ` : ``; + console.warn(`${capitalize(type)} operation ${key}failed: target is readonly.`, toRaw(this)); + } + return type === "delete" /* DELETE */ ? false : this; + }; +} +const mutableInstrumentations = { + get(key) { + return get$1(this, key); + }, + get size() { + return size(this); + }, + has: has$1, + add, + set: set$1, + delete: deleteEntry, + clear, + forEach: createForEach(false, false) +}; +const shallowInstrumentations = { + get(key) { + return get$1(this, key, false, true); + }, + get size() { + return size(this); + }, + has: has$1, + add, + set: set$1, + delete: deleteEntry, + clear, + forEach: createForEach(false, true) +}; +const readonlyInstrumentations = { + get(key) { + return get$1(this, key, true); + }, + get size() { + return size(this, true); + }, + has(key) { + return has$1.call(this, key, true); + }, + add: createReadonlyMethod("add" /* ADD */), + set: createReadonlyMethod("set" /* SET */), + delete: createReadonlyMethod("delete" /* DELETE */), + clear: createReadonlyMethod("clear" /* CLEAR */), + forEach: createForEach(true, false) +}; +const shallowReadonlyInstrumentations = { + get(key) { + return get$1(this, key, true, true); + }, + get size() { + return size(this, true); + }, + has(key) { + return has$1.call(this, key, true); + }, + add: createReadonlyMethod("add" /* ADD */), + set: createReadonlyMethod("set" /* SET */), + delete: createReadonlyMethod("delete" /* DELETE */), + clear: createReadonlyMethod("clear" /* CLEAR */), + forEach: createForEach(true, true) +}; +const iteratorMethods = ['keys', 'values', 'entries', Symbol.iterator]; +iteratorMethods.forEach(method => { + mutableInstrumentations[method] = createIterableMethod(method, false, false); + readonlyInstrumentations[method] = createIterableMethod(method, true, false); + shallowInstrumentations[method] = createIterableMethod(method, false, true); + shallowReadonlyInstrumentations[method] = createIterableMethod(method, true, true); +}); +function createInstrumentationGetter(isReadonly, shallow) { + const instrumentations = shallow + ? isReadonly + ? shallowReadonlyInstrumentations + : shallowInstrumentations + : isReadonly + ? readonlyInstrumentations + : mutableInstrumentations; + return (target, key, receiver) => { + if (key === "__v_isReactive" /* IS_REACTIVE */) { + return !isReadonly; + } + else if (key === "__v_isReadonly" /* IS_READONLY */) { + return isReadonly; + } + else if (key === "__v_raw" /* RAW */) { + return target; + } + return Reflect.get(hasOwn(instrumentations, key) && key in target + ? instrumentations + : target, key, receiver); + }; +} +const mutableCollectionHandlers = { + get: createInstrumentationGetter(false, false) +}; +const shallowCollectionHandlers = { + get: createInstrumentationGetter(false, true) +}; +const readonlyCollectionHandlers = { + get: createInstrumentationGetter(true, false) +}; +const shallowReadonlyCollectionHandlers = { + get: createInstrumentationGetter(true, true) +}; +function checkIdentityKeys(target, has, key) { + const rawKey = toRaw(key); + if (rawKey !== key && has.call(target, rawKey)) { + const type = toRawType(target); + console.warn(`Reactive ${type} contains both the raw and reactive ` + + `versions of the same object${type === `Map` ? ` as keys` : ``}, ` + + `which can lead to inconsistencies. ` + + `Avoid differentiating between the raw and reactive versions ` + + `of an object and only use the reactive version if possible.`); + } +} + +const reactiveMap = new WeakMap(); +const shallowReactiveMap = new WeakMap(); +const readonlyMap = new WeakMap(); +const shallowReadonlyMap = new WeakMap(); +function targetTypeMap(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(value) { + return value["__v_skip" /* SKIP */] || !Object.isExtensible(value) + ? 0 /* INVALID */ + : targetTypeMap(toRawType(value)); +} +function reactive(target) { + // if trying to observe a readonly proxy, return the readonly version. + if (target && target["__v_isReadonly" /* IS_READONLY */]) { + return target; + } + return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers, reactiveMap); +} +/** + * Return a shallowly-reactive copy of the original object, where only the root + * level properties are reactive. It also does not auto-unwrap refs (even at the + * root level). + */ +function shallowReactive(target) { + return createReactiveObject(target, false, shallowReactiveHandlers, shallowCollectionHandlers, shallowReactiveMap); +} +/** + * Creates a readonly copy of the original object. Note the returned copy is not + * made reactive, but `readonly` can be called on an already reactive object. + */ +function readonly(target) { + return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers, readonlyMap); +} +/** + * Returns a reactive-copy of the original object, where only the root level + * properties are readonly, and does NOT unwrap refs nor recursively convert + * returned properties. + * This is used for creating the props proxy object for stateful components. + */ +function shallowReadonly(target) { + return createReactiveObject(target, true, shallowReadonlyHandlers, shallowReadonlyCollectionHandlers, shallowReadonlyMap); +} +function createReactiveObject(target, isReadonly, baseHandlers, collectionHandlers, proxyMap) { + if (!isObject(target)) { + if ((process.env.NODE_ENV !== 'production')) { + console.warn(`value cannot be made reactive: ${String(target)}`); + } + return target; + } + // target is already a Proxy, return it. + // exception: calling readonly() on a reactive object + if (target["__v_raw" /* RAW */] && + !(isReadonly && target["__v_isReactive" /* IS_REACTIVE */])) { + return target; + } + // target already has corresponding Proxy + const existingProxy = proxyMap.get(target); + if (existingProxy) { + return existingProxy; + } + // only a whitelist of value types can be observed. + const targetType = getTargetType(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(value) { + if (isReadonly(value)) { + return isReactive(value["__v_raw" /* RAW */]); + } + return !!(value && value["__v_isReactive" /* IS_REACTIVE */]); +} +function isReadonly(value) { + return !!(value && value["__v_isReadonly" /* IS_READONLY */]); +} +function isProxy(value) { + return isReactive(value) || isReadonly(value); +} +function toRaw(observed) { + return ((observed && toRaw(observed["__v_raw" /* RAW */])) || observed); +} +function markRaw(value) { + def(value, "__v_skip" /* SKIP */, true); + return value; +} + +const convert = (val) => isObject(val) ? reactive(val) : val; +function isRef(r) { + return Boolean(r && r.__v_isRef === true); +} +function ref(value) { + return createRef(value); +} +function shallowRef(value) { + return createRef(value, true); +} +class RefImpl { + constructor(_rawValue, _shallow) { + this._rawValue = _rawValue; + this._shallow = _shallow; + this.__v_isRef = true; + this._value = _shallow ? _rawValue : convert(_rawValue); + } + get value() { + track(toRaw(this), "get" /* GET */, 'value'); + return this._value; + } + set value(newVal) { + if (hasChanged(toRaw(newVal), this._rawValue)) { + this._rawValue = newVal; + this._value = this._shallow ? newVal : convert(newVal); + trigger(toRaw(this), "set" /* SET */, 'value', newVal); + } + } +} +function createRef(rawValue, shallow = false) { + if (isRef(rawValue)) { + return rawValue; + } + return new RefImpl(rawValue, shallow); +} +function triggerRef(ref) { + trigger(toRaw(ref), "set" /* SET */, 'value', (process.env.NODE_ENV !== 'production') ? ref.value : void 0); +} +function unref(ref) { + return isRef(ref) ? ref.value : ref; +} +const shallowUnwrapHandlers = { + get: (target, key, receiver) => unref(Reflect.get(target, key, receiver)), + set: (target, key, value, receiver) => { + const oldValue = target[key]; + if (isRef(oldValue) && !isRef(value)) { + oldValue.value = value; + return true; + } + else { + return Reflect.set(target, key, value, receiver); + } + } +}; +function proxyRefs(objectWithRefs) { + return isReactive(objectWithRefs) + ? objectWithRefs + : new Proxy(objectWithRefs, shallowUnwrapHandlers); +} +class CustomRefImpl { + constructor(factory) { + this.__v_isRef = true; + const { get, set } = factory(() => track(this, "get" /* GET */, 'value'), () => trigger(this, "set" /* SET */, 'value')); + this._get = get; + this._set = set; + } + get value() { + return this._get(); + } + set value(newVal) { + this._set(newVal); + } +} +function customRef(factory) { + return new CustomRefImpl(factory); +} +function toRefs(object) { + if ((process.env.NODE_ENV !== 'production') && !isProxy(object)) { + console.warn(`toRefs() expects a reactive object but received a plain one.`); + } + const ret = isArray(object) ? new Array(object.length) : {}; + for (const key in object) { + ret[key] = toRef(object, key); + } + return ret; +} +class ObjectRefImpl { + constructor(_object, _key) { + this._object = _object; + this._key = _key; + this.__v_isRef = true; + } + get value() { + return this._object[this._key]; + } + set value(newVal) { + this._object[this._key] = newVal; + } +} +function toRef(object, key) { + return isRef(object[key]) + ? object[key] + : new ObjectRefImpl(object, key); +} + +class ComputedRefImpl { + constructor(getter, _setter, isReadonly) { + this._setter = _setter; + this._dirty = true; + this.__v_isRef = true; + this.effect = effect(getter, { + lazy: true, + scheduler: () => { + if (!this._dirty) { + this._dirty = true; + trigger(toRaw(this), "set" /* SET */, 'value'); + } + } + }); + this["__v_isReadonly" /* IS_READONLY */] = isReadonly; + } + get value() { + // the computed ref may get wrapped by other proxies e.g. readonly() #3376 + const self = toRaw(this); + if (self._dirty) { + self._value = this.effect(); + self._dirty = false; + } + track(self, "get" /* GET */, 'value'); + return self._value; + } + set value(newValue) { + this._setter(newValue); + } +} +function computed(getterOrOptions) { + let getter; + let setter; + if (isFunction(getterOrOptions)) { + getter = getterOrOptions; + setter = (process.env.NODE_ENV !== 'production') + ? () => { + console.warn('Write operation failed: computed value is readonly'); + } + : NOOP; + } + else { + getter = getterOrOptions.get; + setter = getterOrOptions.set; + } + return new ComputedRefImpl(getter, setter, isFunction(getterOrOptions) || !getterOrOptions.set); +} + +const stack = []; +function pushWarningContext(vnode) { + stack.push(vnode); +} +function popWarningContext() { + stack.pop(); +} +function warn(msg, ...args) { + // avoid props formatting or warn handler tracking deps that might be mutated + // during patch, leading to infinite recursion. + 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 /* APP_WARN_HANDLER */, [ + msg + args.join(''), + instance && instance.proxy, + trace + .map(({ vnode }) => `at <${formatComponentName(instance, vnode.type)}>`) + .join('\n'), + trace + ]); + } + else { + const warnArgs = [`[Vue warn]: ${msg}`, ...args]; + /* istanbul ignore if */ + if (trace.length && + // avoid spamming console during tests + !false) { + warnArgs.push(`\n`, ...formatTrace(trace)); + } + console.warn(...warnArgs); + } + resetTracking(); +} +function getComponentTrace() { + let currentVNode = stack[stack.length - 1]; + if (!currentVNode) { + return []; + } + // we can't just use the stack because it will be incomplete during updates + // that did not start from the root. Re-construct the parent chain using + // instance parent pointers. + 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; +} +/* istanbul ignore next */ +function formatTrace(trace) { + const logs = []; + trace.forEach((entry, i) => { + logs.push(...(i === 0 ? [] : [`\n`]), ...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]; +} +/* istanbul ignore next */ +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; +} +/* istanbul ignore next */ +function formatProp(key, value, raw) { + if (isString(value)) { + value = JSON.stringify(value); + return raw ? value : [`${key}=${value}`]; + } + else if (typeof value === 'number' || + typeof value === 'boolean' || + value == null) { + return raw ? value : [`${key}=${value}`]; + } + else if (isRef(value)) { + value = formatProp(key, toRaw(value.value), true); + return raw ? value : [`${key}=Ref<`, value, `>`]; + } + else if (isFunction(value)) { + return [`${key}=fn${value.name ? `<${value.name}>` : ``}`]; + } + else { + value = toRaw(value); + return raw ? value : [`${key}=`, value]; + } +} + +const ErrorTypeStrings = { + ["bc" /* BEFORE_CREATE */]: 'beforeCreate hook', + ["c" /* CREATED */]: 'created hook', + ["bm" /* BEFORE_MOUNT */]: 'beforeMount hook', + ["m" /* MOUNTED */]: 'mounted hook', + ["bu" /* BEFORE_UPDATE */]: 'beforeUpdate hook', + ["u" /* UPDATED */]: 'updated', + ["bum" /* BEFORE_UNMOUNT */]: 'beforeUnmount hook', + ["um" /* UNMOUNTED */]: 'unmounted hook', + ["a" /* ACTIVATED */]: 'activated hook', + ["da" /* DEACTIVATED */]: 'deactivated hook', + ["ec" /* ERROR_CAPTURED */]: 'errorCaptured hook', + ["rtc" /* RENDER_TRACKED */]: 'renderTracked hook', + ["rtg" /* RENDER_TRIGGERED */]: 'renderTriggered hook', + [0 /* SETUP_FUNCTION */]: 'setup function', + [1 /* RENDER_FUNCTION */]: 'render function', + [2 /* WATCH_GETTER */]: 'watcher getter', + [3 /* WATCH_CALLBACK */]: 'watcher callback', + [4 /* WATCH_CLEANUP */]: 'watcher cleanup function', + [5 /* NATIVE_EVENT_HANDLER */]: 'native event handler', + [6 /* COMPONENT_EVENT_HANDLER */]: 'component event handler', + [7 /* VNODE_HOOK */]: 'vnode hook', + [8 /* DIRECTIVE_HOOK */]: 'directive hook', + [9 /* TRANSITION_HOOK */]: 'transition hook', + [10 /* APP_ERROR_HANDLER */]: 'app errorHandler', + [11 /* APP_WARN_HANDLER */]: 'app warnHandler', + [12 /* FUNCTION_REF */]: 'ref function', + [13 /* ASYNC_COMPONENT_LOADER */]: 'async component loader', + [14 /* SCHEDULER */]: 'scheduler flush. This is likely a Vue internals bug. ' + + 'Please open an issue at https://new-issue.vuejs.org/?repo=vuejs/vue-next' +}; +function callWithErrorHandling(fn, instance, type, args) { + let res; + try { + res = args ? fn(...args) : fn(); + } + catch (err) { + handleError(err, instance, type); + } + return res; +} +function callWithAsyncErrorHandling(fn, instance, type, args) { + if (isFunction(fn)) { + const res = callWithErrorHandling(fn, instance, type, args); + if (res && isPromise(res)) { + res.catch(err => { + handleError(err, instance, type); + }); + } + return res; + } + const values = []; + for (let i = 0; i < fn.length; i++) { + values.push(callWithAsyncErrorHandling(fn[i], instance, type, args)); + } + return values; +} +function handleError(err, instance, type, throwInDev = true) { + const contextVNode = instance ? instance.vnode : null; + if (instance) { + let cur = instance.parent; + // the exposed instance is the render proxy to keep it consistent with 2.x + const exposedInstance = instance.proxy; + // in production the hook receives only the error code + const errorInfo = (process.env.NODE_ENV !== 'production') ? ErrorTypeStrings[type] : 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; + } + // app-level handling + const appErrorHandler = instance.appContext.config.errorHandler; + if (appErrorHandler) { + callWithErrorHandling(appErrorHandler, null, 10 /* APP_ERROR_HANDLER */, [err, exposedInstance, errorInfo]); + return; + } + } + logError(err, type, contextVNode, throwInDev); +} +function logError(err, type, contextVNode, throwInDev = true) { + if ((process.env.NODE_ENV !== 'production')) { + const info = ErrorTypeStrings[type]; + if (contextVNode) { + pushWarningContext(contextVNode); + } + warn(`Unhandled error${info ? ` during execution of ${info}` : ``}`); + if (contextVNode) { + popWarningContext(); + } + // crash in dev by default so it's more noticeable + if (throwInDev) { + throw err; + } + else { + console.error(err); + } + } + else { + // recover in prod to reduce the impact on end-user + console.error(err); + } +} + +let isFlushing = false; +let isFlushPending = false; +const queue = []; +let flushIndex = 0; +const pendingPreFlushCbs = []; +let activePreFlushCbs = null; +let preFlushIndex = 0; +const pendingPostFlushCbs = []; +let activePostFlushCbs = null; +let postFlushIndex = 0; +const resolvedPromise = Promise.resolve(); +let currentFlushPromise = null; +let currentPreFlushParentJob = null; +const RECURSION_LIMIT = 100; +function nextTick(fn) { + const p = currentFlushPromise || resolvedPromise; + return fn ? p.then(this ? fn.bind(this) : fn) : p; +} +// #2768 +// Use binary-search to find a suitable position in the queue, +// so that the queue maintains the increasing order of job's id, +// which can prevent the job from being skipped and also can avoid repeated patching. +function findInsertionIndex(job) { + // the start index should be `flushIndex + 1` + let start = flushIndex + 1; + let end = queue.length; + const jobId = getId(job); + while (start < end) { + const middle = (start + end) >>> 1; + const middleJobId = getId(queue[middle]); + middleJobId < jobId ? (start = middle + 1) : (end = middle); + } + return start; +} +function queueJob(job) { + // the dedupe search uses the startIndex argument of Array.includes() + // by default the search index includes the current job that is being run + // so it cannot recursively trigger itself again. + // if the job is a watch() callback, the search will start with a +1 index to + // allow it recursively trigger itself - it is the user's responsibility to + // ensure it doesn't end up in an infinite loop. + if ((!queue.length || + !queue.includes(job, isFlushing && job.allowRecurse ? flushIndex + 1 : flushIndex)) && + job !== currentPreFlushParentJob) { + const pos = findInsertionIndex(job); + if (pos > -1) { + queue.splice(pos, 0, job); + } + else { + queue.push(job); + } + queueFlush(); + } +} +function queueFlush() { + if (!isFlushing && !isFlushPending) { + isFlushPending = true; + currentFlushPromise = resolvedPromise.then(flushJobs); + } +} +function invalidateJob(job) { + const i = queue.indexOf(job); + if (i > flushIndex) { + queue.splice(i, 1); + } +} +function queueCb(cb, activeQueue, pendingQueue, index) { + if (!isArray(cb)) { + if (!activeQueue || + !activeQueue.includes(cb, cb.allowRecurse ? index + 1 : index)) { + pendingQueue.push(cb); + } + } + else { + // if cb is an array, it is a component lifecycle hook which can only be + // triggered by a job, which is already deduped in the main queue, so + // we can skip duplicate check here to improve perf + pendingQueue.push(...cb); + } + queueFlush(); +} +function queuePreFlushCb(cb) { + queueCb(cb, activePreFlushCbs, pendingPreFlushCbs, preFlushIndex); +} +function queuePostFlushCb(cb) { + queueCb(cb, activePostFlushCbs, pendingPostFlushCbs, postFlushIndex); +} +function flushPreFlushCbs(seen, parentJob = null) { + if (pendingPreFlushCbs.length) { + currentPreFlushParentJob = parentJob; + activePreFlushCbs = [...new Set(pendingPreFlushCbs)]; + pendingPreFlushCbs.length = 0; + if ((process.env.NODE_ENV !== 'production')) { + seen = seen || new Map(); + } + for (preFlushIndex = 0; preFlushIndex < activePreFlushCbs.length; preFlushIndex++) { + if ((process.env.NODE_ENV !== 'production') && + checkRecursiveUpdates(seen, activePreFlushCbs[preFlushIndex])) { + continue; + } + activePreFlushCbs[preFlushIndex](); + } + activePreFlushCbs = null; + preFlushIndex = 0; + currentPreFlushParentJob = null; + // recursively flush until it drains + flushPreFlushCbs(seen, parentJob); + } +} +function flushPostFlushCbs(seen) { + if (pendingPostFlushCbs.length) { + const deduped = [...new Set(pendingPostFlushCbs)]; + pendingPostFlushCbs.length = 0; + // #1947 already has active queue, nested flushPostFlushCbs call + if (activePostFlushCbs) { + activePostFlushCbs.push(...deduped); + return; + } + activePostFlushCbs = deduped; + if ((process.env.NODE_ENV !== 'production')) { + seen = seen || new Map(); + } + activePostFlushCbs.sort((a, b) => getId(a) - getId(b)); + for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) { + if ((process.env.NODE_ENV !== 'production') && + checkRecursiveUpdates(seen, activePostFlushCbs[postFlushIndex])) { + continue; + } + activePostFlushCbs[postFlushIndex](); + } + activePostFlushCbs = null; + postFlushIndex = 0; + } +} +const getId = (job) => job.id == null ? Infinity : job.id; +function flushJobs(seen) { + isFlushPending = false; + isFlushing = true; + if ((process.env.NODE_ENV !== 'production')) { + seen = seen || new Map(); + } + flushPreFlushCbs(seen); + // Sort queue before flush. + // This ensures that: + // 1. Components are updated from parent to child. (because parent is always + // created before the child so its render effect will have smaller + // priority number) + // 2. If a component is unmounted during a parent component's update, + // its update can be skipped. + queue.sort((a, b) => getId(a) - getId(b)); + try { + for (flushIndex = 0; flushIndex < queue.length; flushIndex++) { + const job = queue[flushIndex]; + if (job && job.active !== false) { + if ((process.env.NODE_ENV !== 'production') && checkRecursiveUpdates(seen, job)) { + continue; + } + callWithErrorHandling(job, null, 14 /* SCHEDULER */); + } + } + } + finally { + flushIndex = 0; + queue.length = 0; + flushPostFlushCbs(seen); + isFlushing = false; + currentFlushPromise = null; + // some postFlushCb queued jobs! + // keep flushing until it drains. + if (queue.length || + pendingPreFlushCbs.length || + pendingPostFlushCbs.length) { + flushJobs(seen); + } + } +} +function checkRecursiveUpdates(seen, fn) { + if (!seen.has(fn)) { + seen.set(fn, 1); + } + else { + const count = seen.get(fn); + if (count > RECURSION_LIMIT) { + const instance = fn.ownerInstance; + const componentName = instance && getComponentName(instance.type); + warn(`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.`); + return true; + } + else { + seen.set(fn, count + 1); + } + } +} + +/* eslint-disable no-restricted-globals */ +let isHmrUpdating = false; +const hmrDirtyComponents = new Set(); +// Expose the HMR runtime on the window object +// This makes it entirely tree-shakable without polluting the exports and makes +// it easier to be used in toolings like vue-loader +// Note: for a component to be eligible for HMR it also needs the __hmrId option +// to be set so that its instances can be registered / removed. +if ((process.env.NODE_ENV !== 'production')) { + const globalObject = typeof window !== 'undefined' + ? window + : typeof self !== 'undefined' + ? self + : typeof window !== 'undefined' + ? window + : {}; + globalObject.__VUE_HMR_RUNTIME__ = { + createRecord: tryWrap(createRecord), + rerender: tryWrap(rerender), + reload: tryWrap(reload) + }; +} +const map = new Map(); +function registerHMR(instance) { + const id = instance.type.__hmrId; + let record = map.get(id); + if (!record) { + createRecord(id, instance.type); + record = map.get(id); + } + record.instances.add(instance); +} +function unregisterHMR(instance) { + map.get(instance.type.__hmrId).instances.delete(instance); +} +function createRecord(id, component) { + if (!component) { + warn(`HMR API usage is out of date.\n` + + `Please upgrade vue-loader/vite/rollup-plugin-vue or other relevant ` + + `dependency that handles Vue SFC compilation.`); + component = {}; + } + if (map.has(id)) { + return false; + } + map.set(id, { + component: isClassComponent(component) ? component.__vccOpts : component, + instances: new Set() + }); + return true; +} +function rerender(id, newRender) { + const record = map.get(id); + if (!record) + return; + if (newRender) + record.component.render = newRender; + // Array.from creates a snapshot which avoids the set being mutated during + // updates + Array.from(record.instances).forEach(instance => { + if (newRender) { + instance.render = newRender; + } + instance.renderCache = []; + // this flag forces child components with slot content to update + isHmrUpdating = true; + instance.update(); + isHmrUpdating = false; + }); +} +function reload(id, newComp) { + const record = map.get(id); + if (!record) + return; + // Array.from creates a snapshot which avoids the set being mutated during + // updates + const { component, instances } = record; + if (!hmrDirtyComponents.has(component)) { + // 1. Update existing comp definition to match new one + newComp = isClassComponent(newComp) ? newComp.__vccOpts : newComp; + extend(component, newComp); + for (const key in component) { + if (key !== '__file' && !(key in newComp)) { + delete component[key]; + } + } + // 2. Mark component dirty. This forces the renderer to replace the component + // on patch. + hmrDirtyComponents.add(component); + // 3. Make sure to unmark the component after the reload. + queuePostFlushCb(() => { + hmrDirtyComponents.delete(component); + }); + } + Array.from(instances).forEach(instance => { + if (instance.parent) { + // 4. Force the parent instance to re-render. This will cause all updated + // components to be unmounted and re-mounted. Queue the update so that we + // don't end up forcing the same parent to re-render multiple times. + queueJob(instance.parent.update); + } + else if (instance.appContext.reload) { + // root instance mounted via createApp() has a reload method + instance.appContext.reload(); + } + else if (typeof window !== 'undefined') { + // root instance inside tree created via raw render(). Force reload. + window.location.reload(); + } + else { + console.warn('[HMR] Root or manually mounted instance modified. Full reload required.'); + } + }); +} +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; +function setDevtoolsHook(hook) { + devtools = hook; +} +function devtoolsInitApp(app, version) { + // TODO queue if devtools is undefined + if (!devtools) + return; + devtools.emit("app:init" /* APP_INIT */, app, version, { + Fragment, + Text, + Comment: Comment$1, + Static + }); +} +function devtoolsUnmountApp(app) { + if (!devtools) + return; + devtools.emit("app:unmount" /* APP_UNMOUNT */, app); +} +const devtoolsComponentAdded = /*#__PURE__*/ createDevtoolsComponentHook("component:added" /* COMPONENT_ADDED */); +const devtoolsComponentUpdated = /*#__PURE__*/ createDevtoolsComponentHook("component:updated" /* COMPONENT_UPDATED */); +const devtoolsComponentRemoved = /*#__PURE__*/ createDevtoolsComponentHook("component:removed" /* COMPONENT_REMOVED */); +function createDevtoolsComponentHook(hook) { + return (component) => { + if (!devtools) + return; + devtools.emit(hook, component.appContext.app, component.uid, component.parent ? component.parent.uid : undefined, component); + }; +} +const devtoolsPerfStart = /*#__PURE__*/ createDevtoolsPerformanceHook("perf:start" /* PERFORMANCE_START */); +const devtoolsPerfEnd = /*#__PURE__*/ createDevtoolsPerformanceHook("perf:end" /* PERFORMANCE_END */); +function createDevtoolsPerformanceHook(hook) { + return (component, type, time) => { + if (!devtools) + return; + devtools.emit(hook, component.appContext.app, component.uid, component, type, time); + }; +} +function devtoolsComponentEmit(component, event, params) { + if (!devtools) + return; + devtools.emit("component:emit" /* COMPONENT_EMIT */, component.appContext.app, component, event, params); +} +const globalCompatConfig = { + MODE: 2 +}; +function getCompatConfigForKey(key, instance) { + const instanceConfig = instance && instance.type.compatConfig; + if (instanceConfig && key in instanceConfig) { + return instanceConfig[key]; + } + return globalCompatConfig[key]; +} +function isCompatEnabled(key, instance, enableForBuiltIn = false) { + // skip compat for built-in components + if (!enableForBuiltIn && instance && instance.type.__isBuiltIn) { + return false; + } + const rawMode = getCompatConfigForKey('MODE', instance) || 2; + const val = getCompatConfigForKey(key, instance); + const mode = isFunction(rawMode) + ? rawMode(instance && instance.type) + : rawMode; + if (mode === 2) { + return val !== false; + } + else { + return val === true || val === 'suppress-warning'; + } +} + +function emit(instance, event, ...rawArgs) { + const props = instance.vnode.props || EMPTY_OBJ; + if ((process.env.NODE_ENV !== 'production')) { + const { emitsOptions, propsOptions: [propsOptions] } = instance; + if (emitsOptions) { + if (!(event in emitsOptions) && + !(false )) { + if (!propsOptions || !(toHandlerKey(event) in propsOptions)) { + warn(`Component emitted event "${event}" but it is neither declared in ` + + `the emits option nor as an "${toHandlerKey(event)}" prop.`); + } + } + else { + const validator = emitsOptions[event]; + if (isFunction(validator)) { + const isValid = validator(...rawArgs); + if (!isValid) { + warn(`Invalid event arguments: event validation failed for event "${event}".`); + } + } + } + } + } + let args = rawArgs; + const isModelListener = event.startsWith('update:'); + // for v-model update:xxx events, apply modifiers on args + const modelArg = isModelListener && event.slice(7); + if (modelArg && modelArg in props) { + const modifiersKey = `${modelArg === 'modelValue' ? 'model' : modelArg}Modifiers`; + const { number, trim } = props[modifiersKey] || EMPTY_OBJ; + if (trim) { + args = rawArgs.map(a => a.trim()); + } + else if (number) { + args = rawArgs.map(toNumber); + } + } + if ((process.env.NODE_ENV !== 'production') || __VUE_PROD_DEVTOOLS__) { + devtoolsComponentEmit(instance, event, args); + } + if ((process.env.NODE_ENV !== 'production')) { + const lowerCaseEvent = event.toLowerCase(); + if (lowerCaseEvent !== event && props[toHandlerKey(lowerCaseEvent)]) { + warn(`Event "${lowerCaseEvent}" is emitted in component ` + + `${formatComponentName(instance, instance.type)} but the handler is registered for "${event}". ` + + `Note that HTML attributes are case-insensitive and you cannot use ` + + `v-on to listen to camelCase events when using in-DOM templates. ` + + `You should probably use "${hyphenate(event)}" instead of "${event}".`); + } + } + let handlerName; + let handler = props[(handlerName = toHandlerKey(event))] || + // also try camelCase event handler (#2249) + props[(handlerName = toHandlerKey(camelize(event)))]; + // for v-model update:xxx events, also trigger kebab-case equivalent + // for props passed via kebab-case + if (!handler && isModelListener) { + handler = props[(handlerName = toHandlerKey(hyphenate(event)))]; + } + if (handler) { + callWithAsyncErrorHandling(handler, instance, 6 /* COMPONENT_EVENT_HANDLER */, args); + } + const onceHandler = props[handlerName + `Once`]; + if (onceHandler) { + if (!instance.emitted) { + instance.emitted = {}; + } + else if (instance.emitted[handlerName]) { + return; + } + instance.emitted[handlerName] = true; + callWithAsyncErrorHandling(onceHandler, instance, 6 /* COMPONENT_EVENT_HANDLER */, args); + } +} +function normalizeEmitsOptions(comp, appContext, asMixin = false) { + const cache = appContext.emitsCache; + const cached = cache.get(comp); + if (cached !== undefined) { + return cached; + } + const raw = comp.emits; + let normalized = {}; + // apply mixin/extends props + let hasExtends = false; + if (__VUE_OPTIONS_API__ && !isFunction(comp)) { + const extendEmits = (raw) => { + const normalizedFromExtend = normalizeEmitsOptions(raw, appContext, true); + if (normalizedFromExtend) { + hasExtends = true; + extend(normalized, normalizedFromExtend); + } + }; + if (!asMixin && appContext.mixins.length) { + appContext.mixins.forEach(extendEmits); + } + if (comp.extends) { + extendEmits(comp.extends); + } + if (comp.mixins) { + comp.mixins.forEach(extendEmits); + } + } + if (!raw && !hasExtends) { + cache.set(comp, null); + return null; + } + if (isArray(raw)) { + raw.forEach(key => (normalized[key] = null)); + } + else { + extend(normalized, raw); + } + cache.set(comp, normalized); + return normalized; +} +// Check if an incoming prop key is a declared emit event listener. +// e.g. With `emits: { click: null }`, props named `onClick` and `onclick` are +// both considered matched listeners. +function isEmitListener(options, key) { + if (!options || !isOn(key)) { + return false; + } + key = key.slice(2).replace(/Once$/, ''); + return (hasOwn(options, key[0].toLowerCase() + key.slice(1)) || + hasOwn(options, hyphenate(key)) || + hasOwn(options, key)); +} + +/** + * mark the current rendering instance for asset resolution (e.g. + * resolveComponent, resolveDirective) during render + */ +let currentRenderingInstance = null; +let currentScopeId = null; +/** + * Note: rendering calls maybe nested. The function returns the parent rendering + * instance if present, which should be restored after the render is done: + * + * ```js + * const prev = setCurrentRenderingInstance(i) + * // ...render + * setCurrentRenderingInstance(prev) + * ``` + */ +function setCurrentRenderingInstance(instance) { + const prev = currentRenderingInstance; + currentRenderingInstance = instance; + currentScopeId = (instance && instance.type.__scopeId) || null; + return prev; +} +/** + * Set scope id when creating hoisted vnodes. + * @private compiler helper + */ +function pushScopeId(id) { + currentScopeId = id; +} +/** + * Technically we no longer need this after 3.0.8 but we need to keep the same + * API for backwards compat w/ code generated by compilers. + * @private + */ +function popScopeId() { + currentScopeId = null; +} +/** + * Only for backwards compat + * @private + */ +const withScopeId = (_id) => withCtx; +/** + * Wrap a slot function to memoize current rendering instance + * @private compiler helper + */ +function withCtx(fn, ctx = currentRenderingInstance, isNonScopedSlot // false only +) { + if (!ctx) + return fn; + // already normalized + if (fn._n) { + return fn; + } + const renderFnWithContext = (...args) => { + // If a user calls a compiled slot inside a template expression (#1745), it + // can mess up block tracking, so by default we disable block tracking and + // force bail out when invoking a compiled slot (indicated by the ._d flag). + // This isn't necessary if rendering a compiled ``, so we flip the + // ._d flag off when invoking the wrapped fn inside `renderSlot`. + if (renderFnWithContext._d) { + setBlockTracking(-1); + } + const prevInstance = setCurrentRenderingInstance(ctx); + const res = fn(...args); + setCurrentRenderingInstance(prevInstance); + if (renderFnWithContext._d) { + setBlockTracking(1); + } + if ((process.env.NODE_ENV !== 'production') || __VUE_PROD_DEVTOOLS__) { + devtoolsComponentUpdated(ctx); + } + return res; + }; + // mark normalized to avoid duplicated wrapping + renderFnWithContext._n = true; + // mark this as compiled by default + // this is used in vnode.ts -> normalizeChildren() to set the slot + // rendering flag. + renderFnWithContext._c = true; + // disable block tracking by default + renderFnWithContext._d = true; + return renderFnWithContext; +} + +/** + * dev only flag to track whether $attrs was used during render. + * If $attrs was used during render then the warning for failed attrs + * fallthrough can be suppressed. + */ +let accessedAttrs = false; +function markAttrsAccessed() { + accessedAttrs = true; +} +function renderComponentRoot(instance) { + const { type: Component, vnode, proxy, withProxy, props, propsOptions: [propsOptions], slots, attrs, emit, render, renderCache, data, setupState, ctx, inheritAttrs } = instance; + let result; + const prev = setCurrentRenderingInstance(instance); + if ((process.env.NODE_ENV !== 'production')) { + accessedAttrs = false; + } + try { + let fallthroughAttrs; + if (vnode.shapeFlag & 4 /* STATEFUL_COMPONENT */) { + // withProxy is a proxy with a different `has` trap only for + // runtime-compiled render functions using `with` block. + const proxyToUse = withProxy || proxy; + result = normalizeVNode(render.call(proxyToUse, proxyToUse, renderCache, props, setupState, data, ctx)); + fallthroughAttrs = attrs; + } + else { + // functional + const render = Component; + // in dev, mark attrs accessed if optional props (attrs === props) + if ((process.env.NODE_ENV !== 'production') && attrs === props) { + markAttrsAccessed(); + } + result = normalizeVNode(render.length > 1 + ? render(props, (process.env.NODE_ENV !== 'production') + ? { + get attrs() { + markAttrsAccessed(); + return attrs; + }, + slots, + emit + } + : { attrs, slots, emit }) + : render(props, null /* we know it doesn't need it */)); + fallthroughAttrs = Component.props + ? attrs + : getFunctionalFallthrough(attrs); + } + // attr merging + // in dev mode, comments are preserved, and it's possible for a template + // to have comments along side the root element which makes it a fragment + let root = result; + let setRoot = undefined; + if ((process.env.NODE_ENV !== 'production') && + result.patchFlag > 0 && + result.patchFlag & 2048 /* DEV_ROOT_FRAGMENT */) { + ; + [root, setRoot] = getChildRoot(result); + } + if (fallthroughAttrs && inheritAttrs !== false) { + const keys = Object.keys(fallthroughAttrs); + const { shapeFlag } = root; + if (keys.length) { + if (shapeFlag & 1 /* ELEMENT */ || + shapeFlag & 6 /* COMPONENT */) { + if (propsOptions && keys.some(isModelListener)) { + // If a v-model listener (onUpdate:xxx) has a corresponding declared + // prop, it indicates this component expects to handle v-model and + // it should not fallthrough. + // related: #1543, #1643, #1989 + fallthroughAttrs = filterModelListeners(fallthroughAttrs, propsOptions); + } + root = cloneVNode(root, fallthroughAttrs); + } + else if ((process.env.NODE_ENV !== 'production') && !accessedAttrs && root.type !== Comment$1) { + const allAttrs = Object.keys(attrs); + const eventAttrs = []; + const extraAttrs = []; + for (let i = 0, l = allAttrs.length; i < l; i++) { + const key = allAttrs[i]; + if (isOn(key)) { + // ignore v-model handlers when they fail to fallthrough + if (!isModelListener(key)) { + // remove `on`, lowercase first letter to reflect event casing + // accurately + eventAttrs.push(key[2].toLowerCase() + key.slice(3)); + } + } + else { + extraAttrs.push(key); + } + } + if (extraAttrs.length) { + warn(`Extraneous non-props attributes (` + + `${extraAttrs.join(', ')}) ` + + `were passed to component but could not be automatically inherited ` + + `because component renders fragment or text root nodes.`); + } + if (eventAttrs.length) { + warn(`Extraneous non-emits event listeners (` + + `${eventAttrs.join(', ')}) ` + + `were passed to component but could not be automatically inherited ` + + `because component renders fragment or text root nodes. ` + + `If the listener is intended to be a component custom event listener only, ` + + `declare it using the "emits" option.`); + } + } + } + } + if (false && + isCompatEnabled("INSTANCE_ATTRS_CLASS_STYLE" /* INSTANCE_ATTRS_CLASS_STYLE */, instance) && + vnode.shapeFlag & 4 /* STATEFUL_COMPONENT */ && + (root.shapeFlag & 1 /* ELEMENT */ || + root.shapeFlag & 6 /* COMPONENT */)) ; + // inherit directives + if (vnode.dirs) { + if ((process.env.NODE_ENV !== 'production') && !isElementRoot(root)) { + warn(`Runtime directive used on component with non-element root node. ` + + `The directives will not function as intended.`); + } + root.dirs = root.dirs ? root.dirs.concat(vnode.dirs) : vnode.dirs; + } + // inherit transition data + if (vnode.transition) { + if ((process.env.NODE_ENV !== 'production') && !isElementRoot(root)) { + warn(`Component inside renders non-element root node ` + + `that cannot be animated.`); + } + root.transition = vnode.transition; + } + if ((process.env.NODE_ENV !== 'production') && setRoot) { + setRoot(root); + } + else { + result = root; + } + } + catch (err) { + blockStack.length = 0; + handleError(err, instance, 1 /* RENDER_FUNCTION */); + result = createVNode(Comment$1); + } + setCurrentRenderingInstance(prev); + return result; +} +/** + * dev only + * In dev mode, template root level comments are rendered, which turns the + * template into a fragment root, but we need to locate the single element + * root for attrs and scope id processing. + */ +const getChildRoot = (vnode) => { + const rawChildren = vnode.children; + const dynamicChildren = vnode.dynamicChildren; + const childRoot = filterSingleRoot(rawChildren); + if (!childRoot) { + return [vnode, undefined]; + } + const index = rawChildren.indexOf(childRoot); + const dynamicIndex = dynamicChildren ? dynamicChildren.indexOf(childRoot) : -1; + const setRoot = (updatedRoot) => { + rawChildren[index] = updatedRoot; + if (dynamicChildren) { + if (dynamicIndex > -1) { + dynamicChildren[dynamicIndex] = updatedRoot; + } + else if (updatedRoot.patchFlag > 0) { + vnode.dynamicChildren = [...dynamicChildren, updatedRoot]; + } + } + }; + return [normalizeVNode(childRoot), setRoot]; +}; +function filterSingleRoot(children) { + let singleRoot; + for (let i = 0; i < children.length; i++) { + const child = children[i]; + if (isVNode(child)) { + // ignore user comment + if (child.type !== Comment$1 || child.children === 'v-if') { + if (singleRoot) { + // has more than 1 non-comment child, return now + return; + } + else { + singleRoot = child; + } + } + } + else { + return; + } + } + return singleRoot; +} +const getFunctionalFallthrough = (attrs) => { + let res; + for (const key in attrs) { + if (key === 'class' || key === 'style' || isOn(key)) { + (res || (res = {}))[key] = attrs[key]; + } + } + return res; +}; +const filterModelListeners = (attrs, props) => { + const res = {}; + for (const key in attrs) { + if (!isModelListener(key) || !(key.slice(9) in props)) { + res[key] = attrs[key]; + } + } + return res; +}; +const isElementRoot = (vnode) => { + return (vnode.shapeFlag & 6 /* COMPONENT */ || + vnode.shapeFlag & 1 /* ELEMENT */ || + vnode.type === Comment$1 // potential v-if branch switch + ); +}; +function shouldUpdateComponent(prevVNode, nextVNode, optimized) { + const { props: prevProps, children: prevChildren, component } = prevVNode; + const { props: nextProps, children: nextChildren, patchFlag } = nextVNode; + const emits = component.emitsOptions; + // Parent component's render function was hot-updated. Since this may have + // caused the child component's slots content to have changed, we need to + // force the child to update as well. + if ((process.env.NODE_ENV !== 'production') && (prevChildren || nextChildren) && isHmrUpdating) { + return true; + } + // force child update for runtime directive or transition on component vnode. + if (nextVNode.dirs || nextVNode.transition) { + return true; + } + if (optimized && patchFlag >= 0) { + if (patchFlag & 1024 /* DYNAMIC_SLOTS */) { + // slot content that references values that might have changed, + // e.g. in a v-for + return true; + } + if (patchFlag & 16 /* FULL_PROPS */) { + if (!prevProps) { + return !!nextProps; + } + // presence of this flag indicates props are always non-null + return hasPropsChanged(prevProps, nextProps, emits); + } + else if (patchFlag & 8 /* PROPS */) { + const dynamicProps = nextVNode.dynamicProps; + for (let i = 0; i < dynamicProps.length; i++) { + const key = dynamicProps[i]; + if (nextProps[key] !== prevProps[key] && + !isEmitListener(emits, key)) { + return true; + } + } + } + } + else { + // this path is only taken by manually written render functions + // so presence of any children leads to a forced update + if (prevChildren || nextChildren) { + if (!nextChildren || !nextChildren.$stable) { + return true; + } + } + if (prevProps === nextProps) { + return false; + } + if (!prevProps) { + return !!nextProps; + } + if (!nextProps) { + return true; + } + return hasPropsChanged(prevProps, nextProps, emits); + } + return false; +} +function hasPropsChanged(prevProps, nextProps, emitsOptions) { + const nextKeys = Object.keys(nextProps); + if (nextKeys.length !== Object.keys(prevProps).length) { + return true; + } + for (let i = 0; i < nextKeys.length; i++) { + const key = nextKeys[i]; + if (nextProps[key] !== prevProps[key] && + !isEmitListener(emitsOptions, key)) { + return true; + } + } + return false; +} +function updateHOCHostEl({ vnode, parent }, el // HostNode +) { + while (parent && parent.subTree === vnode) { + (vnode = parent.vnode).el = el; + parent = parent.parent; + } +} + +const isSuspense = (type) => type.__isSuspense; +// Suspense exposes a component-like API, and is treated like a component +// in the compiler, but internally it's a special built-in type that hooks +// directly into the renderer. +const SuspenseImpl = { + name: 'Suspense', + // In order to make Suspense tree-shakable, we need to avoid importing it + // directly in the renderer. The renderer checks for the __isSuspense flag + // on a vnode's type and calls the `process` method, passing in renderer + // internals. + __isSuspense: true, + process(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, + // platform-specific impl passed from renderer + rendererInternals) { + if (n1 == null) { + mountSuspense(n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, rendererInternals); + } + else { + patchSuspense(n1, n2, container, anchor, parentComponent, isSVG, slotScopeIds, optimized, rendererInternals); + } + }, + hydrate: hydrateSuspense, + create: createSuspenseBoundary, + normalize: normalizeSuspenseChildren +}; +// Force-casted public typing for h and TSX props inference +const Suspense = (SuspenseImpl + ); +function triggerEvent(vnode, name) { + const eventListener = vnode.props && vnode.props[name]; + if (isFunction(eventListener)) { + eventListener(); + } +} +function mountSuspense(vnode, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, rendererInternals) { + const { p: patch, o: { createElement } } = rendererInternals; + const hiddenContainer = createElement('div', container); // fixed by xxxxxx + const suspense = (vnode.suspense = createSuspenseBoundary(vnode, parentSuspense, parentComponent, container, hiddenContainer, anchor, isSVG, slotScopeIds, optimized, rendererInternals)); + // start mounting the content subtree in an off-dom container + patch(null, (suspense.pendingBranch = vnode.ssContent), hiddenContainer, null, parentComponent, suspense, isSVG, slotScopeIds); + // now check if we have encountered any async deps + if (suspense.deps > 0) { + // has async + // invoke @fallback event + triggerEvent(vnode, 'onPending'); + triggerEvent(vnode, 'onFallback'); + // mount the fallback tree + patch(null, vnode.ssFallback, container, anchor, parentComponent, null, // fallback tree will not have suspense context + isSVG, slotScopeIds); + setActiveBranch(suspense, vnode.ssFallback); + } + else { + // Suspense has no async deps. Just resolve. + suspense.resolve(); + } +} +function patchSuspense(n1, n2, container, anchor, parentComponent, isSVG, slotScopeIds, optimized, { p: patch, um: unmount, o: { createElement } }) { + const suspense = (n2.suspense = n1.suspense); + suspense.vnode = n2; + n2.el = n1.el; + const newBranch = n2.ssContent; + const newFallback = n2.ssFallback; + const { activeBranch, pendingBranch, isInFallback, isHydrating } = suspense; + if (pendingBranch) { + suspense.pendingBranch = newBranch; + if (isSameVNodeType(newBranch, pendingBranch)) { + // same root type but content may have changed. + patch(pendingBranch, newBranch, suspense.hiddenContainer, null, parentComponent, suspense, isSVG, slotScopeIds, optimized); + if (suspense.deps <= 0) { + suspense.resolve(); + } + else if (isInFallback) { + patch(activeBranch, newFallback, container, anchor, parentComponent, null, // fallback tree will not have suspense context + isSVG, slotScopeIds, optimized); + setActiveBranch(suspense, newFallback); + } + } + else { + // toggled before pending tree is resolved + suspense.pendingId++; + if (isHydrating) { + // if toggled before hydration is finished, the current DOM tree is + // no longer valid. set it as the active branch so it will be unmounted + // when resolved + suspense.isHydrating = false; + suspense.activeBranch = pendingBranch; + } + else { + unmount(pendingBranch, parentComponent, suspense); + } + // increment pending ID. this is used to invalidate async callbacks + // reset suspense state + suspense.deps = 0; + // discard effects from pending branch + suspense.effects.length = 0; + // discard previous container + suspense.hiddenContainer = createElement('div', container); // fixed by xxxxxx + if (isInFallback) { + // already in fallback state + patch(null, newBranch, suspense.hiddenContainer, null, parentComponent, suspense, isSVG, slotScopeIds, optimized); + if (suspense.deps <= 0) { + suspense.resolve(); + } + else { + patch(activeBranch, newFallback, container, anchor, parentComponent, null, // fallback tree will not have suspense context + isSVG, slotScopeIds, optimized); + setActiveBranch(suspense, newFallback); + } + } + else if (activeBranch && isSameVNodeType(newBranch, activeBranch)) { + // toggled "back" to current active branch + patch(activeBranch, newBranch, container, anchor, parentComponent, suspense, isSVG, slotScopeIds, optimized); + // force resolve + suspense.resolve(true); + } + else { + // switched to a 3rd branch + patch(null, newBranch, suspense.hiddenContainer, null, parentComponent, suspense, isSVG, slotScopeIds, optimized); + if (suspense.deps <= 0) { + suspense.resolve(); + } + } + } + } + else { + if (activeBranch && isSameVNodeType(newBranch, activeBranch)) { + // root did not change, just normal patch + patch(activeBranch, newBranch, container, anchor, parentComponent, suspense, isSVG, slotScopeIds, optimized); + setActiveBranch(suspense, newBranch); + } + else { + // root node toggled + // invoke @pending event + triggerEvent(n2, 'onPending'); + // mount pending branch in off-dom container + suspense.pendingBranch = newBranch; + suspense.pendingId++; + patch(null, newBranch, suspense.hiddenContainer, null, parentComponent, suspense, isSVG, slotScopeIds, optimized); + if (suspense.deps <= 0) { + // incoming branch has no async deps, resolve now. + suspense.resolve(); + } + else { + const { timeout, pendingId } = suspense; + if (timeout > 0) { + setTimeout(() => { + if (suspense.pendingId === pendingId) { + suspense.fallback(newFallback); + } + }, timeout); + } + else if (timeout === 0) { + suspense.fallback(newFallback); + } + } + } + } +} +let hasWarned = false; +function createSuspenseBoundary(vnode, parent, parentComponent, container, hiddenContainer, anchor, isSVG, slotScopeIds, optimized, rendererInternals, isHydrating = false) { + /* istanbul ignore if */ + if ((process.env.NODE_ENV !== 'production') && !false && !hasWarned) { + hasWarned = true; + // @ts-ignore `console.info` cannot be null error + console[console.info ? 'info' : 'log'](` is an experimental feature and its API will likely change.`); + } + const { p: patch, m: move, um: unmount, n: next, o: { parentNode, remove } } = rendererInternals; + const timeout = toNumber(vnode.props && vnode.props.timeout); + const suspense = { + vnode, + parent, + parentComponent, + isSVG, + container, + hiddenContainer, + anchor, + deps: 0, + pendingId: 0, + timeout: typeof timeout === 'number' ? timeout : -1, + activeBranch: null, + pendingBranch: null, + isInFallback: true, + isHydrating, + isUnmounted: false, + effects: [], + resolve(resume = false) { + if ((process.env.NODE_ENV !== 'production')) { + if (!resume && !suspense.pendingBranch) { + throw new Error(`suspense.resolve() is called without a pending branch.`); + } + if (suspense.isUnmounted) { + throw new Error(`suspense.resolve() is called on an already unmounted suspense boundary.`); + } + } + const { vnode, activeBranch, pendingBranch, pendingId, effects, parentComponent, container } = suspense; + if (suspense.isHydrating) { + suspense.isHydrating = false; + } + else if (!resume) { + const delayEnter = activeBranch && + pendingBranch.transition && + pendingBranch.transition.mode === 'out-in'; + if (delayEnter) { + activeBranch.transition.afterLeave = () => { + if (pendingId === suspense.pendingId) { + move(pendingBranch, container, anchor, 0 /* ENTER */); + } + }; + } + // this is initial anchor on mount + let { anchor } = suspense; + // unmount current active tree + if (activeBranch) { + // if the fallback tree was mounted, it may have been moved + // as part of a parent suspense. get the latest anchor for insertion + anchor = next(activeBranch); + unmount(activeBranch, parentComponent, suspense, true); + } + if (!delayEnter) { + // move content from off-dom container to actual container + move(pendingBranch, container, anchor, 0 /* ENTER */); + } + } + setActiveBranch(suspense, pendingBranch); + suspense.pendingBranch = null; + suspense.isInFallback = false; + // flush buffered effects + // check if there is a pending parent suspense + let parent = suspense.parent; + let hasUnresolvedAncestor = false; + while (parent) { + if (parent.pendingBranch) { + // found a pending parent suspense, merge buffered post jobs + // into that parent + parent.effects.push(...effects); + hasUnresolvedAncestor = true; + break; + } + parent = parent.parent; + } + // no pending parent suspense, flush all jobs + if (!hasUnresolvedAncestor) { + queuePostFlushCb(effects); + } + suspense.effects = []; + // invoke @resolve event + triggerEvent(vnode, 'onResolve'); + }, + fallback(fallbackVNode) { + if (!suspense.pendingBranch) { + return; + } + const { vnode, activeBranch, parentComponent, container, isSVG } = suspense; + // invoke @fallback event + triggerEvent(vnode, 'onFallback'); + const anchor = next(activeBranch); + const mountFallback = () => { + if (!suspense.isInFallback) { + return; + } + // mount the fallback tree + patch(null, fallbackVNode, container, anchor, parentComponent, null, // fallback tree will not have suspense context + isSVG, slotScopeIds, optimized); + setActiveBranch(suspense, fallbackVNode); + }; + const delayEnter = fallbackVNode.transition && fallbackVNode.transition.mode === 'out-in'; + if (delayEnter) { + activeBranch.transition.afterLeave = mountFallback; + } + suspense.isInFallback = true; + // unmount current active branch + unmount(activeBranch, parentComponent, null, // no suspense so unmount hooks fire now + true // shouldRemove + ); + if (!delayEnter) { + mountFallback(); + } + }, + move(container, anchor, type) { + suspense.activeBranch && + move(suspense.activeBranch, container, anchor, type); + suspense.container = container; + }, + next() { + return suspense.activeBranch && next(suspense.activeBranch); + }, + registerDep(instance, setupRenderEffect) { + const isInPendingSuspense = !!suspense.pendingBranch; + if (isInPendingSuspense) { + suspense.deps++; + } + const hydratedEl = instance.vnode.el; + instance + .asyncDep.catch(err => { + handleError(err, instance, 0 /* SETUP_FUNCTION */); + }) + .then(asyncSetupResult => { + // retry when the setup() promise resolves. + // component may have been unmounted before resolve. + if (instance.isUnmounted || + suspense.isUnmounted || + suspense.pendingId !== instance.suspenseId) { + return; + } + // retry from this component + instance.asyncResolved = true; + const { vnode } = instance; + if ((process.env.NODE_ENV !== 'production')) { + pushWarningContext(vnode); + } + handleSetupResult(instance, asyncSetupResult, false); + if (hydratedEl) { + // vnode may have been replaced if an update happened before the + // async dep is resolved. + vnode.el = hydratedEl; + } + const placeholder = !hydratedEl && instance.subTree.el; + setupRenderEffect(instance, vnode, + // component may have been moved before resolve. + // if this is not a hydration, instance.subTree will be the comment + // placeholder. + parentNode(hydratedEl || instance.subTree.el), + // anchor will not be used if this is hydration, so only need to + // consider the comment placeholder case. + hydratedEl ? null : next(instance.subTree), suspense, isSVG, optimized); + if (placeholder) { + remove(placeholder); + } + updateHOCHostEl(instance, vnode.el); + if ((process.env.NODE_ENV !== 'production')) { + popWarningContext(); + } + // only decrease deps count if suspense is not already resolved + if (isInPendingSuspense && --suspense.deps === 0) { + suspense.resolve(); + } + }); + }, + unmount(parentSuspense, doRemove) { + suspense.isUnmounted = true; + if (suspense.activeBranch) { + unmount(suspense.activeBranch, parentComponent, parentSuspense, doRemove); + } + if (suspense.pendingBranch) { + unmount(suspense.pendingBranch, parentComponent, parentSuspense, doRemove); + } + } + }; + return suspense; +} +function hydrateSuspense(node, vnode, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, rendererInternals, hydrateNode) { + /* eslint-disable no-restricted-globals */ + const suspense = (vnode.suspense = createSuspenseBoundary(vnode, parentSuspense, parentComponent, node.parentNode, document.createElement('div'), null, isSVG, slotScopeIds, optimized, rendererInternals, true /* hydrating */)); + // there are two possible scenarios for server-rendered suspense: + // - success: ssr content should be fully resolved + // - failure: ssr content should be the fallback branch. + // however, on the client we don't really know if it has failed or not + // attempt to hydrate the DOM assuming it has succeeded, but we still + // need to construct a suspense boundary first + const result = hydrateNode(node, (suspense.pendingBranch = vnode.ssContent), parentComponent, suspense, slotScopeIds, optimized); + if (suspense.deps === 0) { + suspense.resolve(); + } + return result; + /* eslint-enable no-restricted-globals */ +} +function normalizeSuspenseChildren(vnode) { + const { shapeFlag, children } = vnode; + const isSlotChildren = shapeFlag & 32 /* SLOTS_CHILDREN */; + vnode.ssContent = normalizeSuspenseSlot(isSlotChildren ? children.default : children); + vnode.ssFallback = isSlotChildren + ? normalizeSuspenseSlot(children.fallback) + : createVNode(Comment); +} +function normalizeSuspenseSlot(s) { + let block; + if (isFunction(s)) { + const isCompiledSlot = s._c; + if (isCompiledSlot) { + // disableTracking: false + // allow block tracking for compiled slots + // (see ./componentRenderContext.ts) + s._d = false; + openBlock(); + } + s = s(); + if (isCompiledSlot) { + s._d = true; + block = currentBlock; + closeBlock(); + } + } + if (isArray(s)) { + const singleChild = filterSingleRoot(s); + if ((process.env.NODE_ENV !== 'production') && !singleChild) { + warn(` slots expect a single root node.`); + } + s = singleChild; + } + s = normalizeVNode(s); + if (block) { + s.dynamicChildren = block.filter(c => c !== s); + } + return s; +} +function queueEffectWithSuspense(fn, suspense) { + if (suspense && suspense.pendingBranch) { + if (isArray(fn)) { + suspense.effects.push(...fn); + } + else { + suspense.effects.push(fn); + } + } + else { + queuePostFlushCb(fn); + } +} +function setActiveBranch(suspense, branch) { + suspense.activeBranch = branch; + const { vnode, parentComponent } = suspense; + const el = (vnode.el = branch.el); + // in case suspense is the root node of a component, + // recursively update the HOC el + if (parentComponent && parentComponent.subTree === vnode) { + parentComponent.vnode.el = el; + updateHOCHostEl(parentComponent, el); + } +} + +function provide(key, value) { + if (!currentInstance) { + if ((process.env.NODE_ENV !== 'production')) { + warn(`provide() can only be used inside setup().`); + } + } + else { + let provides = currentInstance.provides; + // by default an instance inherits its parent's provides object + // but when it needs to provide values of its own, it creates its + // own provides object using parent provides object as prototype. + // this way in `inject` we can simply look up injections from direct + // parent and let the prototype chain do the work. + const parentProvides = currentInstance.parent && currentInstance.parent.provides; + if (parentProvides === provides) { + provides = currentInstance.provides = Object.create(parentProvides); + } + // TS doesn't allow symbol as index type + provides[key] = value; + } +} +function inject(key, defaultValue, treatDefaultAsFactory = false) { + // fallback to `currentRenderingInstance` so that this can be called in + // a functional component + const instance = currentInstance || currentRenderingInstance; + if (instance) { + // #2400 + // to support `app.use` plugins, + // fallback to appContext's `provides` if the intance is at root + const provides = instance.parent == null + ? instance.vnode.appContext && instance.vnode.appContext.provides + : instance.parent.provides; + if (provides && key in provides) { + // TS doesn't allow symbol as index type + return provides[key]; + } + else if (arguments.length > 1) { + return treatDefaultAsFactory && isFunction(defaultValue) + ? defaultValue.call(instance.proxy) + : defaultValue; + } + else if ((process.env.NODE_ENV !== 'production')) { + warn(`injection "${String(key)}" not found.`); + } + } + else if ((process.env.NODE_ENV !== 'production')) { + warn(`inject() can only be used inside setup() or functional components.`); + } +} + +// Simple effect. +function watchEffect(effect, options) { + return doWatch(effect, null, options); +} +// initial value for watchers to trigger on undefined initial values +const INITIAL_WATCHER_VALUE = {}; +// implementation +function watch(source, cb, options) { + if ((process.env.NODE_ENV !== 'production') && !isFunction(cb)) { + warn(`\`watch(fn, options?)\` signature has been moved to a separate API. ` + + `Use \`watchEffect(fn, options?)\` instead. \`watch\` now only ` + + `supports \`watch(source, cb, options?) signature.`); + } + return doWatch(source, cb, options); +} +function doWatch(source, cb, { immediate, deep, flush, onTrack, onTrigger } = EMPTY_OBJ, instance = currentInstance) { + if ((process.env.NODE_ENV !== 'production') && !cb) { + if (immediate !== undefined) { + warn(`watch() "immediate" option is only respected when using the ` + + `watch(source, callback, options?) signature.`); + } + if (deep !== undefined) { + warn(`watch() "deep" option is only respected when using the ` + + `watch(source, callback, options?) signature.`); + } + } + const warnInvalidSource = (s) => { + warn(`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.`); + }; + let getter; + let forceTrigger = false; + let isMultiSource = false; + if (isRef(source)) { + getter = () => source.value; + forceTrigger = !!source._shallow; + } + else if (isReactive(source)) { + getter = () => source; + deep = true; + } + else if (isArray(source)) { + isMultiSource = true; + forceTrigger = source.some(isReactive); + getter = () => source.map(s => { + if (isRef(s)) { + return s.value; + } + else if (isReactive(s)) { + return traverse(s); + } + else if (isFunction(s)) { + return callWithErrorHandling(s, instance, 2 /* WATCH_GETTER */); + } + else { + (process.env.NODE_ENV !== 'production') && warnInvalidSource(s); + } + }); + } + else if (isFunction(source)) { + if (cb) { + // getter with cb + getter = () => callWithErrorHandling(source, instance, 2 /* WATCH_GETTER */); + } + else { + // no cb -> simple effect + getter = () => { + if (instance && instance.isUnmounted) { + return; + } + if (cleanup) { + cleanup(); + } + return callWithAsyncErrorHandling(source, instance, 3 /* WATCH_CALLBACK */, [onInvalidate]); + }; + } + } + else { + getter = NOOP; + (process.env.NODE_ENV !== 'production') && warnInvalidSource(source); + } + if (cb && deep) { + const baseGetter = getter; + getter = () => traverse(baseGetter()); + } + let cleanup; + let onInvalidate = (fn) => { + cleanup = runner.options.onStop = () => { + callWithErrorHandling(fn, instance, 4 /* WATCH_CLEANUP */); + }; + }; + let oldValue = isMultiSource ? [] : INITIAL_WATCHER_VALUE; + const job = () => { + if (!runner.active) { + return; + } + if (cb) { + // watch(source, cb) + const newValue = runner(); + if (deep || + forceTrigger || + (isMultiSource + ? newValue.some((v, i) => hasChanged(v, oldValue[i])) + : hasChanged(newValue, oldValue)) || + (false )) { + // cleanup before running cb again + if (cleanup) { + cleanup(); + } + callWithAsyncErrorHandling(cb, instance, 3 /* WATCH_CALLBACK */, [ + newValue, + // pass undefined as the old value when it's changed for the first time + oldValue === INITIAL_WATCHER_VALUE ? undefined : oldValue, + onInvalidate + ]); + oldValue = newValue; + } + } + else { + // watchEffect + runner(); + } + }; + // important: mark the job as a watcher callback so that scheduler knows + // it is allowed to self-trigger (#1727) + job.allowRecurse = !!cb; + let scheduler; + if (flush === 'sync') { + scheduler = job; // the scheduler function gets called directly + } + else if (flush === 'post') { + scheduler = () => queuePostRenderEffect(job, instance && instance.suspense); + } + else { + // default: 'pre' + scheduler = () => { + if (!instance || instance.isMounted) { + queuePreFlushCb(job); + } + else { + // with 'pre' option, the first call must happen before + // the component is mounted so it is called synchronously. + job(); + } + }; + } + const runner = effect(getter, { + lazy: true, + onTrack, + onTrigger, + scheduler + }); + recordInstanceBoundEffect(runner, instance); + // initial run + if (cb) { + if (immediate) { + job(); + } + else { + oldValue = runner(); + } + } + else if (flush === 'post') { + queuePostRenderEffect(runner, instance && instance.suspense); + } + else { + runner(); + } + return () => { + stop(runner); + if (instance) { + remove(instance.effects, runner); + } + }; +} +// this.$watch +function instanceWatch(source, value, options) { + const publicThis = this.proxy; + const getter = isString(source) + ? source.includes('.') + ? createPathGetter(publicThis, source) + : () => publicThis[source] + : source.bind(publicThis, publicThis); + let cb; + if (isFunction(value)) { + cb = value; + } + else { + cb = value.handler; + options = value; + } + return doWatch(getter, cb.bind(publicThis), options, this); +} +function createPathGetter(ctx, path) { + const segments = path.split('.'); + return () => { + let cur = ctx; + for (let i = 0; i < segments.length && cur; i++) { + cur = cur[segments[i]]; + } + return cur; + }; +} +function traverse(value, seen = new Set()) { + if (!isObject(value) || + seen.has(value) || + value["__v_skip" /* SKIP */]) { + return value; + } + seen.add(value); + if (isRef(value)) { + traverse(value.value, seen); + } + else if (isArray(value)) { + for (let i = 0; i < value.length; i++) { + traverse(value[i], seen); + } + } + else if (isSet(value) || isMap(value)) { + value.forEach((v) => { + traverse(v, seen); + }); + } + else if (isPlainObject(value)) { + for (const key in value) { + traverse(value[key], seen); + } + } + return value; +} + +function useTransitionState() { + const state = { + isMounted: false, + isLeaving: false, + isUnmounting: false, + leavingVNodes: new Map() + }; + onMounted(() => { + state.isMounted = true; + }); + onBeforeUnmount(() => { + state.isUnmounting = true; + }); + return state; +} +const TransitionHookValidator = [Function, Array]; +const BaseTransitionImpl = { + name: `BaseTransition`, + props: { + mode: String, + appear: Boolean, + persisted: Boolean, + // enter + onBeforeEnter: TransitionHookValidator, + onEnter: TransitionHookValidator, + onAfterEnter: TransitionHookValidator, + onEnterCancelled: TransitionHookValidator, + // leave + onBeforeLeave: TransitionHookValidator, + onLeave: TransitionHookValidator, + onAfterLeave: TransitionHookValidator, + onLeaveCancelled: TransitionHookValidator, + // appear + onBeforeAppear: TransitionHookValidator, + onAppear: TransitionHookValidator, + onAfterAppear: TransitionHookValidator, + onAppearCancelled: TransitionHookValidator + }, + setup(props, { slots }) { + const instance = getCurrentInstance(); + const state = useTransitionState(); + let prevTransitionKey; + return () => { + const children = slots.default && getTransitionRawChildren(slots.default(), true); + if (!children || !children.length) { + return; + } + // warn multiple elements + if ((process.env.NODE_ENV !== 'production') && children.length > 1) { + warn(' can only be used on a single element or component. Use ' + + ' for lists.'); + } + // there's no need to track reactivity for these props so use the raw + // props for a bit better perf + const rawProps = toRaw(props); + const { mode } = rawProps; + // check mode + if ((process.env.NODE_ENV !== 'production') && mode && !['in-out', 'out-in', 'default'].includes(mode)) { + warn(`invalid mode: ${mode}`); + } + // at this point children has a guaranteed length of 1. + const child = children[0]; + if (state.isLeaving) { + return emptyPlaceholder(child); + } + // in the case of , we need to + // compare the type of the kept-alive children. + const innerChild = getKeepAliveChild(child); + if (!innerChild) { + return emptyPlaceholder(child); + } + const enterHooks = resolveTransitionHooks(innerChild, rawProps, state, instance); + setTransitionHooks(innerChild, enterHooks); + const oldChild = instance.subTree; + const oldInnerChild = oldChild && getKeepAliveChild(oldChild); + let transitionKeyChanged = false; + const { getTransitionKey } = innerChild.type; + if (getTransitionKey) { + const key = getTransitionKey(); + if (prevTransitionKey === undefined) { + prevTransitionKey = key; + } + else if (key !== prevTransitionKey) { + prevTransitionKey = key; + transitionKeyChanged = true; + } + } + // handle mode + if (oldInnerChild && + oldInnerChild.type !== Comment$1 && + (!isSameVNodeType(innerChild, oldInnerChild) || transitionKeyChanged)) { + const leavingHooks = resolveTransitionHooks(oldInnerChild, rawProps, state, instance); + // update old tree's hooks in case of dynamic transition + setTransitionHooks(oldInnerChild, leavingHooks); + // switching between different views + if (mode === 'out-in') { + state.isLeaving = true; + // return placeholder node and queue update when leave finishes + leavingHooks.afterLeave = () => { + state.isLeaving = false; + instance.update(); + }; + return emptyPlaceholder(child); + } + else if (mode === 'in-out' && innerChild.type !== Comment$1) { + leavingHooks.delayLeave = (el, earlyRemove, delayedLeave) => { + const leavingVNodesCache = getLeavingNodesForType(state, oldInnerChild); + leavingVNodesCache[String(oldInnerChild.key)] = oldInnerChild; + // early removal callback + el._leaveCb = () => { + earlyRemove(); + el._leaveCb = undefined; + delete enterHooks.delayedLeave; + }; + enterHooks.delayedLeave = delayedLeave; + }; + } + } + return child; + }; + } +}; +// export the public type for h/tsx inference +// also to avoid inline import() in generated d.ts files +const BaseTransition = BaseTransitionImpl; +function getLeavingNodesForType(state, vnode) { + const { leavingVNodes } = state; + let leavingVNodesCache = leavingVNodes.get(vnode.type); + if (!leavingVNodesCache) { + leavingVNodesCache = Object.create(null); + leavingVNodes.set(vnode.type, leavingVNodesCache); + } + return leavingVNodesCache; +} +// The transition hooks are attached to the vnode as vnode.transition +// and will be called at appropriate timing in the renderer. +function resolveTransitionHooks(vnode, props, state, instance) { + const { appear, mode, persisted = false, onBeforeEnter, onEnter, onAfterEnter, onEnterCancelled, onBeforeLeave, onLeave, onAfterLeave, onLeaveCancelled, onBeforeAppear, onAppear, onAfterAppear, onAppearCancelled } = props; + const key = String(vnode.key); + const leavingVNodesCache = getLeavingNodesForType(state, vnode); + const callHook = (hook, args) => { + hook && + callWithAsyncErrorHandling(hook, instance, 9 /* TRANSITION_HOOK */, args); + }; + const hooks = { + mode, + persisted, + beforeEnter(el) { + let hook = onBeforeEnter; + if (!state.isMounted) { + if (appear) { + hook = onBeforeAppear || onBeforeEnter; + } + else { + return; + } + } + // for same element (v-show) + if (el._leaveCb) { + el._leaveCb(true /* cancelled */); + } + // for toggled element with same key (v-if) + const leavingVNode = leavingVNodesCache[key]; + if (leavingVNode && + isSameVNodeType(vnode, leavingVNode) && + leavingVNode.el._leaveCb) { + // force early removal (not cancelled) + leavingVNode.el._leaveCb(); + } + callHook(hook, [el]); + }, + enter(el) { + let hook = onEnter; + let afterHook = onAfterEnter; + let cancelHook = onEnterCancelled; + if (!state.isMounted) { + if (appear) { + hook = onAppear || onEnter; + afterHook = onAfterAppear || onAfterEnter; + cancelHook = onAppearCancelled || onEnterCancelled; + } + else { + return; + } + } + let called = false; + const done = (el._enterCb = (cancelled) => { + if (called) + return; + called = true; + if (cancelled) { + callHook(cancelHook, [el]); + } + else { + callHook(afterHook, [el]); + } + if (hooks.delayedLeave) { + hooks.delayedLeave(); + } + el._enterCb = undefined; + }); + if (hook) { + hook(el, done); + if (hook.length <= 1) { + done(); + } + } + else { + done(); + } + }, + leave(el, remove) { + const key = String(vnode.key); + if (el._enterCb) { + el._enterCb(true /* cancelled */); + } + if (state.isUnmounting) { + return remove(); + } + callHook(onBeforeLeave, [el]); + let called = false; + const done = (el._leaveCb = (cancelled) => { + if (called) + return; + called = true; + remove(); + if (cancelled) { + callHook(onLeaveCancelled, [el]); + } + else { + callHook(onAfterLeave, [el]); + } + el._leaveCb = undefined; + if (leavingVNodesCache[key] === vnode) { + delete leavingVNodesCache[key]; + } + }); + leavingVNodesCache[key] = vnode; + if (onLeave) { + onLeave(el, done); + if (onLeave.length <= 1) { + done(); + } + } + else { + done(); + } + }, + clone(vnode) { + return resolveTransitionHooks(vnode, props, state, instance); + } + }; + return hooks; +} +// the placeholder really only handles one special case: KeepAlive +// in the case of a KeepAlive in a leave phase we need to return a KeepAlive +// placeholder with empty content to avoid the KeepAlive instance from being +// unmounted. +function emptyPlaceholder(vnode) { + if (isKeepAlive(vnode)) { + vnode = cloneVNode(vnode); + vnode.children = null; + return vnode; + } +} +function getKeepAliveChild(vnode) { + return isKeepAlive(vnode) + ? vnode.children + ? vnode.children[0] + : undefined + : vnode; +} +function setTransitionHooks(vnode, hooks) { + if (vnode.shapeFlag & 6 /* COMPONENT */ && vnode.component) { + setTransitionHooks(vnode.component.subTree, hooks); + } + else if (vnode.shapeFlag & 128 /* SUSPENSE */) { + vnode.ssContent.transition = hooks.clone(vnode.ssContent); + vnode.ssFallback.transition = hooks.clone(vnode.ssFallback); + } + else { + vnode.transition = hooks; + } +} +function getTransitionRawChildren(children, keepComment = false) { + let ret = []; + let keyedFragmentCount = 0; + for (let i = 0; i < children.length; i++) { + const child = children[i]; + // handle fragment children case, e.g. v-for + if (child.type === Fragment) { + if (child.patchFlag & 128 /* KEYED_FRAGMENT */) + keyedFragmentCount++; + ret = ret.concat(getTransitionRawChildren(child.children, keepComment)); + } + // comment placeholders should be skipped, e.g. v-if + else if (keepComment || child.type !== Comment$1) { + ret.push(child); + } + } + // #1126 if a transition children list contains multiple sub fragments, these + // fragments will be merged into a flat children array. Since each v-for + // fragment may contain different static bindings inside, we need to de-op + // these children to force full diffs to ensure correct behavior. + if (keyedFragmentCount > 1) { + for (let i = 0; i < ret.length; i++) { + ret[i].patchFlag = -2 /* BAIL */; + } + } + return ret; +} + +// implementation, close to no-op +function defineComponent(options) { + return isFunction(options) ? { setup: options, name: options.name } : options; +} + +const isAsyncWrapper = (i) => !!i.type.__asyncLoader; +function defineAsyncComponent(source) { + if (isFunction(source)) { + source = { loader: source }; + } + const { loader, loadingComponent, errorComponent, delay = 200, timeout, // undefined = never times out + suspensible = true, onError: userOnError } = source; + let pendingRequest = null; + let resolvedComp; + let retries = 0; + const retry = () => { + retries++; + pendingRequest = null; + return load(); + }; + const load = () => { + let thisRequest; + return (pendingRequest || + (thisRequest = pendingRequest = loader() + .catch(err => { + err = err instanceof Error ? err : new Error(String(err)); + if (userOnError) { + return new Promise((resolve, reject) => { + const userRetry = () => resolve(retry()); + const userFail = () => reject(err); + userOnError(err, userRetry, userFail, retries + 1); + }); + } + else { + throw err; + } + }) + .then((comp) => { + if (thisRequest !== pendingRequest && pendingRequest) { + return pendingRequest; + } + if ((process.env.NODE_ENV !== 'production') && !comp) { + warn(`Async component loader resolved to undefined. ` + + `If you are using retry(), make sure to return its return value.`); + } + // interop module default + if (comp && + (comp.__esModule || comp[Symbol.toStringTag] === 'Module')) { + comp = comp.default; + } + if ((process.env.NODE_ENV !== 'production') && comp && !isObject(comp) && !isFunction(comp)) { + throw new Error(`Invalid async component load result: ${comp}`); + } + resolvedComp = comp; + return comp; + }))); + }; + return defineComponent({ + name: 'AsyncComponentWrapper', + __asyncLoader: load, + get __asyncResolved() { + return resolvedComp; + }, + setup() { + const instance = currentInstance; + // already resolved + if (resolvedComp) { + return () => createInnerComp(resolvedComp, instance); + } + const onError = (err) => { + pendingRequest = null; + handleError(err, instance, 13 /* ASYNC_COMPONENT_LOADER */, !errorComponent /* do not throw in dev if user provided error component */); + }; + // suspense-controlled or SSR. + if ((suspensible && instance.suspense) || + (false )) { + return load() + .then(comp => { + return () => createInnerComp(comp, instance); + }) + .catch(err => { + onError(err); + return () => errorComponent + ? createVNode(errorComponent, { + error: err + }) + : null; + }); + } + const loaded = ref(false); + const error = ref(); + const delayed = ref(!!delay); + if (delay) { + setTimeout(() => { + delayed.value = false; + }, delay); + } + if (timeout != null) { + setTimeout(() => { + if (!loaded.value && !error.value) { + const err = new Error(`Async component timed out after ${timeout}ms.`); + onError(err); + error.value = err; + } + }, timeout); + } + load() + .then(() => { + loaded.value = true; + if (instance.parent && isKeepAlive(instance.parent.vnode)) { + // parent is keep-alive, force update so the loaded component's + // name is taken into account + queueJob(instance.parent.update); + } + }) + .catch(err => { + onError(err); + error.value = err; + }); + return () => { + if (loaded.value && resolvedComp) { + return createInnerComp(resolvedComp, instance); + } + else if (error.value && errorComponent) { + return createVNode(errorComponent, { + error: error.value + }); + } + else if (loadingComponent && !delayed.value) { + return createVNode(loadingComponent); + } + }; + } + }); +} +function createInnerComp(comp, { vnode: { ref, props, children } }) { + const vnode = createVNode(comp, props, children); + // ensure inner component inherits the async wrapper's ref owner + vnode.ref = ref; + return vnode; +} + +const isKeepAlive = (vnode) => vnode.type.__isKeepAlive; +const KeepAliveImpl = { + name: `KeepAlive`, + // Marker for special handling inside the renderer. We are not using a === + // check directly on KeepAlive in the renderer, because importing it directly + // would prevent it from being tree-shaken. + __isKeepAlive: true, + props: { + include: [String, RegExp, Array], + exclude: [String, RegExp, Array], + max: [String, Number] + }, + setup(props, { slots }) { + const instance = getCurrentInstance(); + // KeepAlive communicates with the instantiated renderer via the + // ctx where the renderer passes in its internals, + // and the KeepAlive instance exposes activate/deactivate implementations. + // The whole point of this is to avoid importing KeepAlive directly in the + // renderer to facilitate tree-shaking. + const sharedContext = instance.ctx; + // if the internal renderer is not registered, it indicates that this is server-side rendering, + // for KeepAlive, we just need to render its children + if (!sharedContext.renderer) { + return slots.default; + } + const cache = new Map(); + const keys = new Set(); + let current = null; + if ((process.env.NODE_ENV !== 'production') || __VUE_PROD_DEVTOOLS__) { + instance.__v_cache = cache; + } + const parentSuspense = instance.suspense; + const { renderer: { p: patch, m: move, um: _unmount, o: { createElement } } } = sharedContext; + const storageContainer = createElement('div', null); // fixed by xxxxx + sharedContext.activate = (vnode, container, anchor, isSVG, optimized) => { + const instance = vnode.component; + move(vnode, container, anchor, 0 /* ENTER */, parentSuspense); + // in case props have changed + patch(instance.vnode, vnode, container, anchor, instance, parentSuspense, isSVG, vnode.slotScopeIds, optimized); + queuePostRenderEffect(() => { + instance.isDeactivated = false; + if (instance.a) { + invokeArrayFns(instance.a); + } + const vnodeHook = vnode.props && vnode.props.onVnodeMounted; + if (vnodeHook) { + invokeVNodeHook(vnodeHook, instance.parent, vnode); + } + }, parentSuspense); + if ((process.env.NODE_ENV !== 'production') || __VUE_PROD_DEVTOOLS__) { + // Update components tree + devtoolsComponentAdded(instance); + } + }; + sharedContext.deactivate = (vnode) => { + const instance = vnode.component; + move(vnode, storageContainer, null, 1 /* LEAVE */, parentSuspense); + queuePostRenderEffect(() => { + if (instance.da) { + invokeArrayFns(instance.da); + } + const vnodeHook = vnode.props && vnode.props.onVnodeUnmounted; + if (vnodeHook) { + invokeVNodeHook(vnodeHook, instance.parent, vnode); + } + instance.isDeactivated = true; + }, parentSuspense); + if ((process.env.NODE_ENV !== 'production') || __VUE_PROD_DEVTOOLS__) { + // Update components tree + devtoolsComponentAdded(instance); + } + }; + function unmount(vnode) { + // reset the shapeFlag so it can be properly unmounted + resetShapeFlag(vnode); + _unmount(vnode, instance, parentSuspense); + } + function pruneCache(filter) { + cache.forEach((vnode, key) => { + const name = getComponentName(vnode.type); + if (name && (!filter || !filter(name))) { + pruneCacheEntry(key); + } + }); + } + function pruneCacheEntry(key) { + const cached = cache.get(key); + if (!current || cached.type !== current.type) { + unmount(cached); + } + else if (current) { + // current active instance should no longer be kept-alive. + // we can't unmount it now but it might be later, so reset its flag now. + resetShapeFlag(current); + } + cache.delete(key); + keys.delete(key); + } + // prune cache on include/exclude prop change + watch(() => [props.include, props.exclude], ([include, exclude]) => { + include && pruneCache(name => matches(include, name)); + exclude && pruneCache(name => !matches(exclude, name)); + }, + // prune post-render after `current` has been updated + { flush: 'post', deep: true }); + // cache sub tree after render + let pendingCacheKey = null; + const cacheSubtree = () => { + // fix #1621, the pendingCacheKey could be 0 + if (pendingCacheKey != null) { + cache.set(pendingCacheKey, getInnerChild(instance.subTree)); + } + }; + onMounted(cacheSubtree); + onUpdated(cacheSubtree); + onBeforeUnmount(() => { + cache.forEach(cached => { + const { subTree, suspense } = instance; + const vnode = getInnerChild(subTree); + if (cached.type === vnode.type) { + // current instance will be unmounted as part of keep-alive's unmount + resetShapeFlag(vnode); + // but invoke its deactivated hook here + const da = vnode.component.da; + da && queuePostRenderEffect(da, suspense); + return; + } + unmount(cached); + }); + }); + return () => { + pendingCacheKey = null; + if (!slots.default) { + return null; + } + const children = slots.default(); + const rawVNode = children[0]; + if (children.length > 1) { + if ((process.env.NODE_ENV !== 'production')) { + warn(`KeepAlive should contain exactly one component child.`); + } + current = null; + return children; + } + else if (!isVNode(rawVNode) || + (!(rawVNode.shapeFlag & 4 /* STATEFUL_COMPONENT */) && + !(rawVNode.shapeFlag & 128 /* SUSPENSE */))) { + current = null; + return rawVNode; + } + let vnode = getInnerChild(rawVNode); + const comp = vnode.type; + // for async components, name check should be based in its loaded + // inner component if available + const name = getComponentName(isAsyncWrapper(vnode) + ? vnode.type.__asyncResolved || {} + : comp); + const { include, exclude, max } = props; + if ((include && (!name || !matches(include, name))) || + (exclude && name && matches(exclude, name))) { + current = vnode; + return rawVNode; + } + const key = vnode.key == null ? comp : vnode.key; + const cachedVNode = cache.get(key); + // clone vnode if it's reused because we are going to mutate it + if (vnode.el) { + vnode = cloneVNode(vnode); + if (rawVNode.shapeFlag & 128 /* SUSPENSE */) { + rawVNode.ssContent = vnode; + } + } + // #1513 it's possible for the returned vnode to be cloned due to attr + // fallthrough or scopeId, so the vnode here may not be the final vnode + // that is mounted. Instead of caching it directly, we store the pending + // key and cache `instance.subTree` (the normalized vnode) in + // beforeMount/beforeUpdate hooks. + pendingCacheKey = key; + if (cachedVNode) { + // copy over mounted state + vnode.el = cachedVNode.el; + vnode.component = cachedVNode.component; + if (vnode.transition) { + // recursively update transition hooks on subTree + setTransitionHooks(vnode, vnode.transition); + } + // avoid vnode being mounted as fresh + vnode.shapeFlag |= 512 /* COMPONENT_KEPT_ALIVE */; + // make this key the freshest + keys.delete(key); + keys.add(key); + } + else { + keys.add(key); + // prune oldest entry + if (max && keys.size > parseInt(max, 10)) { + pruneCacheEntry(keys.values().next().value); + } + } + // avoid vnode being unmounted + vnode.shapeFlag |= 256 /* COMPONENT_SHOULD_KEEP_ALIVE */; + current = vnode; + return rawVNode; + }; + } +}; +// export the public type for h/tsx inference +// also to avoid inline import() in generated d.ts files +const KeepAlive = KeepAliveImpl; +function matches(pattern, name) { + if (isArray(pattern)) { + return pattern.some((p) => matches(p, name)); + } + else if (isString(pattern)) { + return pattern.split(',').indexOf(name) > -1; + } + else if (pattern.test) { + return pattern.test(name); + } + /* istanbul ignore next */ + return false; +} +function onActivated(hook, target) { + registerKeepAliveHook(hook, "a" /* ACTIVATED */, target); +} +function onDeactivated(hook, target) { + registerKeepAliveHook(hook, "da" /* DEACTIVATED */, target); +} +function registerKeepAliveHook(hook, type, target = currentInstance) { + // cache the deactivate branch check wrapper for injected hooks so the same + // hook can be properly deduped by the scheduler. "__wdc" stands for "with + // deactivation check". + const wrappedHook = hook.__wdc || + (hook.__wdc = () => { + // only fire the hook if the target instance is NOT in a deactivated branch. + let current = target; + while (current) { + if (current.isDeactivated) { + return; + } + current = current.parent; + } + hook(); + }); + injectHook(type, wrappedHook, target); + // In addition to registering it on the target instance, we walk up the parent + // chain and register it on all ancestor instances that are keep-alive roots. + // This avoids the need to walk the entire component tree when invoking these + // hooks, and more importantly, avoids the need to track child components in + // arrays. + if (target) { + let current = target.parent; + while (current && current.parent) { + if (isKeepAlive(current.parent.vnode)) { + injectToKeepAliveRoot(wrappedHook, type, target, current); + } + current = current.parent; + } + } +} +function injectToKeepAliveRoot(hook, type, target, keepAliveRoot) { + // injectHook wraps the original for error handling, so make sure to remove + // the wrapped version. + const injected = injectHook(type, hook, keepAliveRoot, true /* prepend */); + onUnmounted(() => { + remove(keepAliveRoot[type], injected); + }, target); +} +function resetShapeFlag(vnode) { + let shapeFlag = vnode.shapeFlag; + if (shapeFlag & 256 /* COMPONENT_SHOULD_KEEP_ALIVE */) { + shapeFlag -= 256 /* COMPONENT_SHOULD_KEEP_ALIVE */; + } + if (shapeFlag & 512 /* COMPONENT_KEPT_ALIVE */) { + shapeFlag -= 512 /* COMPONENT_KEPT_ALIVE */; + } + vnode.shapeFlag = shapeFlag; +} +function getInnerChild(vnode) { + return vnode.shapeFlag & 128 /* SUSPENSE */ ? vnode.ssContent : vnode; +} + +function injectHook(type, hook, target = currentInstance, prepend = false) { + if (target) { + const hooks = target[type] || (target[type] = []); + // cache the error handling wrapper for injected hooks so the same hook + // can be properly deduped by the scheduler. "__weh" stands for "with error + // handling". + const wrappedHook = hook.__weh || + (hook.__weh = (...args) => { + if (target.isUnmounted) { + return; + } + // disable tracking inside all lifecycle hooks + // since they can potentially be called inside effects. + pauseTracking(); + // Set currentInstance during hook invocation. + // This assumes the hook does not synchronously trigger other hooks, which + // can only be false when the user does something really funky. + setCurrentInstance(target); + const res = callWithAsyncErrorHandling(hook, target, type, args); + setCurrentInstance(null); + resetTracking(); + return res; + }); + if (prepend) { + hooks.unshift(wrappedHook); + } + else { + hooks.push(wrappedHook); + } + return wrappedHook; + } + else if ((process.env.NODE_ENV !== 'production')) { + const apiName = toHandlerKey(ErrorTypeStrings[type].replace(/ hook$/, '')); + warn(`${apiName} is called when there is no active component instance to be ` + + `associated with. ` + + `Lifecycle injection APIs can only be used during execution of setup().` + + (` If you are using async setup(), make sure to register lifecycle ` + + `hooks before the first await statement.` + )); + } +} +const createHook = (lifecycle) => (hook, target = currentInstance) => +// post-create lifecycle registrations are noops during SSR (except for serverPrefetch) +(!isInSSRComponentSetup || lifecycle === "sp" /* SERVER_PREFETCH */) && + injectHook(lifecycle, hook, target); +const onBeforeMount = createHook("bm" /* BEFORE_MOUNT */); +const onMounted = createHook("m" /* MOUNTED */); +const onBeforeUpdate = createHook("bu" /* BEFORE_UPDATE */); +const onUpdated = createHook("u" /* UPDATED */); +const onBeforeUnmount = createHook("bum" /* BEFORE_UNMOUNT */); +const onUnmounted = createHook("um" /* UNMOUNTED */); +const onServerPrefetch = createHook("sp" /* SERVER_PREFETCH */); +const onRenderTriggered = createHook("rtg" /* RENDER_TRIGGERED */); +const onRenderTracked = createHook("rtc" /* RENDER_TRACKED */); +function onErrorCaptured(hook, target = currentInstance) { + injectHook("ec" /* ERROR_CAPTURED */, hook, target); +} + +function createDuplicateChecker() { + const cache = Object.create(null); + return (type, key) => { + if (cache[key]) { + warn(`${type} property "${key}" is already defined in ${cache[key]}.`); + } + else { + cache[key] = type; + } + }; +} +let shouldCacheAccess = true; +function applyOptions(instance) { + const options = resolveMergedOptions(instance); + const publicThis = instance.proxy; + const ctx = instance.ctx; + // do not cache property access on public proxy during state initialization + shouldCacheAccess = false; + // call beforeCreate first before accessing other options since + // the hook may mutate resolved options (#2791) + if (options.beforeCreate) { + callHook(options.beforeCreate, instance, "bc" /* BEFORE_CREATE */); + } + const { + // state + data: dataOptions, computed: computedOptions, methods, watch: watchOptions, provide: provideOptions, inject: injectOptions, + // lifecycle + created, beforeMount, mounted, beforeUpdate, updated, activated, deactivated, beforeDestroy, beforeUnmount, destroyed, unmounted, render, renderTracked, renderTriggered, errorCaptured, serverPrefetch, + // public API + expose, inheritAttrs, + // assets + components, directives, filters } = options; + const checkDuplicateProperties = (process.env.NODE_ENV !== 'production') ? createDuplicateChecker() : null; + if ((process.env.NODE_ENV !== 'production')) { + const [propsOptions] = instance.propsOptions; + if (propsOptions) { + for (const key in propsOptions) { + checkDuplicateProperties("Props" /* PROPS */, key); + } + } + } + // options initialization order (to be consistent with Vue 2): + // - props (already done outside of this function) + // - inject + // - methods + // - data (deferred since it relies on `this` access) + // - computed + // - watch (deferred since it relies on `this` access) + if (injectOptions) { + resolveInjections(injectOptions, ctx, checkDuplicateProperties); + } + if (methods) { + for (const key in methods) { + const methodHandler = methods[key]; + if (isFunction(methodHandler)) { + // In dev mode, we use the `createRenderContext` function to define methods to the proxy target, + // and those are read-only but reconfigurable, so it needs to be redefined here + if ((process.env.NODE_ENV !== 'production')) { + Object.defineProperty(ctx, key, { + value: methodHandler.bind(publicThis), + configurable: true, + enumerable: true, + writable: true + }); + } + else { + ctx[key] = methodHandler.bind(publicThis); + } + if ((process.env.NODE_ENV !== 'production')) { + checkDuplicateProperties("Methods" /* METHODS */, key); + } + } + else if ((process.env.NODE_ENV !== 'production')) { + warn(`Method "${key}" has type "${typeof methodHandler}" in the component definition. ` + + `Did you reference the function correctly?`); + } + } + } + if (dataOptions) { + if ((process.env.NODE_ENV !== 'production') && !isFunction(dataOptions)) { + warn(`The data option must be a function. ` + + `Plain object usage is no longer supported.`); + } + const data = dataOptions.call(publicThis, publicThis); + if ((process.env.NODE_ENV !== 'production') && isPromise(data)) { + warn(`data() returned a Promise - note data() cannot be async; If you ` + + `intend to perform data fetching before component renders, use ` + + `async setup() + .`); + } + if (!isObject(data)) { + (process.env.NODE_ENV !== 'production') && warn(`data() should return an object.`); + } + else { + instance.data = reactive(data); + if ((process.env.NODE_ENV !== 'production')) { + for (const key in data) { + checkDuplicateProperties("Data" /* DATA */, key); + // expose data on ctx during dev + if (key[0] !== '$' && key[0] !== '_') { + Object.defineProperty(ctx, key, { + configurable: true, + enumerable: true, + get: () => data[key], + set: NOOP + }); + } + } + } + } + } + // state initialization complete at this point - start caching access + shouldCacheAccess = true; + if (computedOptions) { + for (const key in computedOptions) { + const opt = computedOptions[key]; + const get = isFunction(opt) + ? opt.bind(publicThis, publicThis) + : isFunction(opt.get) + ? opt.get.bind(publicThis, publicThis) + : NOOP; + if ((process.env.NODE_ENV !== 'production') && get === NOOP) { + warn(`Computed property "${key}" has no getter.`); + } + const set = !isFunction(opt) && isFunction(opt.set) + ? opt.set.bind(publicThis) + : (process.env.NODE_ENV !== 'production') + ? () => { + warn(`Write operation failed: computed property "${key}" is readonly.`); + } + : NOOP; + const c = computed$1({ + get, + set + }); + Object.defineProperty(ctx, key, { + enumerable: true, + configurable: true, + get: () => c.value, + set: v => (c.value = v) + }); + if ((process.env.NODE_ENV !== 'production')) { + checkDuplicateProperties("Computed" /* COMPUTED */, key); + } + } + } + if (watchOptions) { + for (const key in watchOptions) { + createWatcher(watchOptions[key], ctx, publicThis, key); + } + } + if (provideOptions) { + const provides = isFunction(provideOptions) + ? provideOptions.call(publicThis) + : provideOptions; + Reflect.ownKeys(provides).forEach(key => { + provide(key, provides[key]); + }); + } + if (created) { + callHook(created, instance, "c" /* CREATED */); + } + function registerLifecycleHook(register, hook) { + if (isArray(hook)) { + hook.forEach(_hook => register(_hook.bind(publicThis))); + } + else if (hook) { + register(hook.bind(publicThis)); + } + } + registerLifecycleHook(onBeforeMount, beforeMount); + registerLifecycleHook(onMounted, mounted); + registerLifecycleHook(onBeforeUpdate, beforeUpdate); + registerLifecycleHook(onUpdated, updated); + registerLifecycleHook(onActivated, activated); + registerLifecycleHook(onDeactivated, deactivated); + registerLifecycleHook(onErrorCaptured, errorCaptured); + registerLifecycleHook(onRenderTracked, renderTracked); + registerLifecycleHook(onRenderTriggered, renderTriggered); + registerLifecycleHook(onBeforeUnmount, beforeUnmount); + registerLifecycleHook(onUnmounted, unmounted); + registerLifecycleHook(onServerPrefetch, serverPrefetch); + if (isArray(expose)) { + if (expose.length) { + const exposed = instance.exposed || (instance.exposed = {}); + expose.forEach(key => { + Object.defineProperty(exposed, key, { + get: () => publicThis[key], + set: val => (publicThis[key] = val) + }); + }); + } + else if (!instance.exposed) { + instance.exposed = {}; + } + } + // options that are handled when creating the instance but also need to be + // applied from mixins + if (render && instance.render === NOOP) { + instance.render = render; + } + if (inheritAttrs != null) { + instance.inheritAttrs = inheritAttrs; + } + // asset options. + if (components) + instance.components = components; + if (directives) + instance.directives = directives; +} +function resolveInjections(injectOptions, ctx, checkDuplicateProperties = NOOP) { + if (isArray(injectOptions)) { + injectOptions = normalizeInject(injectOptions); + } + for (const key in injectOptions) { + const opt = injectOptions[key]; + if (isObject(opt)) { + if ('default' in opt) { + ctx[key] = inject(opt.from || key, opt.default, true /* treat default function as factory */); + } + else { + ctx[key] = inject(opt.from || key); + } + } + else { + ctx[key] = inject(opt); + } + if ((process.env.NODE_ENV !== 'production')) { + checkDuplicateProperties("Inject" /* INJECT */, key); + } + } +} +function callHook(hook, instance, type) { + callWithAsyncErrorHandling(isArray(hook) + ? hook.map(h => h.bind(instance.proxy)) + : hook.bind(instance.proxy), instance, type); +} +function createWatcher(raw, ctx, publicThis, key) { + const getter = key.includes('.') + ? createPathGetter(publicThis, key) + : () => publicThis[key]; + if (isString(raw)) { + const handler = ctx[raw]; + if (isFunction(handler)) { + watch(getter, handler); + } + else if ((process.env.NODE_ENV !== 'production')) { + warn(`Invalid watch handler specified by key "${raw}"`, handler); + } + } + else if (isFunction(raw)) { + watch(getter, raw.bind(publicThis)); + } + else if (isObject(raw)) { + if (isArray(raw)) { + raw.forEach(r => createWatcher(r, ctx, publicThis, key)); + } + else { + const handler = isFunction(raw.handler) + ? raw.handler.bind(publicThis) + : ctx[raw.handler]; + if (isFunction(handler)) { + watch(getter, handler, raw); + } + else if ((process.env.NODE_ENV !== 'production')) { + warn(`Invalid watch handler specified by key "${raw.handler}"`, handler); + } + } + } + else if ((process.env.NODE_ENV !== 'production')) { + warn(`Invalid watch option: "${key}"`, raw); + } +} +/** + * Resolve merged options and cache it on the component. + * This is done only once per-component since the merging does not involve + * instances. + */ +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); + } + 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') { + (process.env.NODE_ENV !== 'production') && + warn(`"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: mergeObjectOptions, + emits: mergeObjectOptions, + // objects + methods: mergeObjectOptions, + computed: mergeObjectOptions, + // lifecycle + beforeCreate: mergeAsArray, + created: mergeAsArray, + beforeMount: mergeAsArray, + mounted: mergeAsArray, + beforeUpdate: mergeAsArray, + updated: mergeAsArray, + beforeDestroy: mergeAsArray, + destroyed: mergeAsArray, + activated: mergeAsArray, + deactivated: mergeAsArray, + errorCaptured: mergeAsArray, + serverPrefetch: mergeAsArray, + // assets + components: mergeObjectOptions, + directives: mergeObjectOptions, + // watch + watch: mergeWatchOptions, + // provide / inject + provide: mergeDataFn, + inject: mergeInject +}; +function mergeDataFn(to, from) { + if (!from) { + return to; + } + if (!to) { + return from; + } + return function mergedDataFn() { + return (extend)(isFunction(to) ? to.call(this, this) : to, isFunction(from) ? from.call(this, this) : from); + }; +} +function mergeInject(to, from) { + return mergeObjectOptions(normalizeInject(to), normalizeInject(from)); +} +function normalizeInject(raw) { + if (isArray(raw)) { + const res = {}; + for (let i = 0; i < raw.length; i++) { + res[raw[i]] = raw[i]; + } + return res; + } + return raw; +} +function mergeAsArray(to, from) { + return to ? [...new Set([].concat(to, from))] : from; +} +function mergeObjectOptions(to, from) { + return to ? extend(extend(Object.create(null), to), from) : from; +} +function mergeWatchOptions(to, from) { + if (!to) + return from; + if (!from) + return to; + const merged = extend(Object.create(null), to); + for (const key in from) { + merged[key] = mergeAsArray(to[key], from[key]); + } + return merged; +} + +function initProps(instance, rawProps, isStateful, // result of bitwise flag comparison +isSSR = false) { + const props = {}; + const attrs = {}; + def(attrs, InternalObjectKey, 1); + instance.propsDefaults = Object.create(null); + setFullProps(instance, rawProps, props, attrs); + // ensure all declared prop keys are present + for (const key in instance.propsOptions[0]) { + if (!(key in props)) { + props[key] = undefined; + } + } + // validation + if ((process.env.NODE_ENV !== 'production')) { + validateProps(rawProps || {}, props, instance); + } + if (isStateful) { + // stateful + instance.props = isSSR ? props : shallowReactive(props); + } + else { + if (!instance.type.props) { + // functional w/ optional props, props === attrs + instance.props = attrs; + } + else { + // functional w/ declared props + instance.props = props; + } + } + instance.attrs = attrs; +} +function updateProps(instance, rawProps, rawPrevProps, optimized) { + const { props, attrs, vnode: { patchFlag } } = instance; + const rawCurrentProps = toRaw(props); + const [options] = instance.propsOptions; + let hasAttrsChanged = false; + if ( + // always force full diff in dev + // - #1942 if hmr is enabled with sfc component + // - vite#872 non-sfc component used by sfc component + !((process.env.NODE_ENV !== 'production') && + (instance.type.__hmrId || + (instance.parent && instance.parent.type.__hmrId))) && + (optimized || patchFlag > 0) && + !(patchFlag & 16 /* FULL_PROPS */)) { + if (patchFlag & 8 /* PROPS */) { + // Compiler-generated props & no keys change, just set the updated + // the props. + const propsToUpdate = instance.vnode.dynamicProps; + for (let i = 0; i < propsToUpdate.length; i++) { + let key = propsToUpdate[i]; + // PROPS flag guarantees rawProps to be non-null + const value = rawProps[key]; + if (options) { + // attr / props separation was done on init and will be consistent + // in this code path, so just check if attrs have it. + if (hasOwn(attrs, key)) { + if (value !== attrs[key]) { + attrs[key] = value; + hasAttrsChanged = true; + } + } + else { + const camelizedKey = camelize(key); + props[camelizedKey] = resolvePropValue(options, rawCurrentProps, camelizedKey, value, instance, false /* isAbsent */); + } + } + else { + if (value !== attrs[key]) { + attrs[key] = value; + hasAttrsChanged = true; + } + } + } + } + } + else { + // full props update. + if (setFullProps(instance, rawProps, props, attrs)) { + hasAttrsChanged = true; + } + // in case of dynamic props, check if we need to delete keys from + // the props object + let kebabKey; + for (const key in rawCurrentProps) { + if (!rawProps || + // for camelCase + (!hasOwn(rawProps, key) && + // it's possible the original props was passed in as kebab-case + // and converted to camelCase (#955) + ((kebabKey = hyphenate(key)) === key || !hasOwn(rawProps, kebabKey)))) { + if (options) { + if (rawPrevProps && + // for camelCase + (rawPrevProps[key] !== undefined || + // for kebab-case + rawPrevProps[kebabKey] !== undefined)) { + props[key] = resolvePropValue(options, rawCurrentProps, key, undefined, instance, true /* isAbsent */); + } + } + else { + delete props[key]; + } + } + } + // in the case of functional component w/o props declaration, props and + // attrs point to the same object so it should already have been updated. + if (attrs !== rawCurrentProps) { + for (const key in attrs) { + if (!rawProps || !hasOwn(rawProps, key)) { + delete attrs[key]; + hasAttrsChanged = true; + } + } + } + } + // trigger updates for $attrs in case it's used in component slots + if (hasAttrsChanged) { + trigger(instance, "set" /* SET */, '$attrs'); + } + if ((process.env.NODE_ENV !== 'production')) { + validateProps(rawProps || {}, props, instance); + } +} +function setFullProps(instance, rawProps, props, attrs) { + const [options, needCastKeys] = instance.propsOptions; + let hasAttrsChanged = false; + let rawCastValues; + if (rawProps) { + for (let key in rawProps) { + // key, ref are reserved and never passed down + if (isReservedProp(key)) { + continue; + } + const value = rawProps[key]; + // prop option names are camelized during normalization, so to support + // kebab -> camel conversion here we need to camelize the key. + let camelKey; + if (options && hasOwn(options, (camelKey = camelize(key)))) { + if (!needCastKeys || !needCastKeys.includes(camelKey)) { + props[camelKey] = value; + } + else { + (rawCastValues || (rawCastValues = {}))[camelKey] = value; + } + } + else if (!isEmitListener(instance.emitsOptions, key)) { + if (value !== attrs[key]) { + attrs[key] = value; + hasAttrsChanged = true; + } + } + } + } + if (needCastKeys) { + const rawCurrentProps = toRaw(props); + const castValues = rawCastValues || EMPTY_OBJ; + for (let i = 0; i < needCastKeys.length; i++) { + const key = needCastKeys[i]; + props[key] = resolvePropValue(options, rawCurrentProps, key, castValues[key], instance, !hasOwn(castValues, key)); + } + } + return hasAttrsChanged; +} +function resolvePropValue(options, props, key, value, instance, isAbsent) { + const opt = options[key]; + if (opt != null) { + const hasDefault = hasOwn(opt, 'default'); + // default values + if (hasDefault && value === undefined) { + const defaultValue = opt.default; + if (opt.type !== Function && isFunction(defaultValue)) { + const { propsDefaults } = instance; + if (key in propsDefaults) { + value = propsDefaults[key]; + } + else { + setCurrentInstance(instance); + value = propsDefaults[key] = defaultValue.call(null, props); + setCurrentInstance(null); + } + } + else { + value = defaultValue; + } + } + // boolean casting + if (opt[0 /* shouldCast */]) { + if (isAbsent && !hasDefault) { + value = false; + } + else if (opt[1 /* shouldCastTrue */] && + (value === '' || value === hyphenate(key))) { + value = true; + } + } + } + return value; +} +function normalizePropsOptions(comp, appContext, asMixin = false) { + const cache = appContext.propsCache; + const cached = cache.get(comp); + if (cached) { + return cached; + } + const raw = comp.props; + const normalized = {}; + const needCastKeys = []; + // apply mixin/extends props + let hasExtends = false; + if (__VUE_OPTIONS_API__ && !isFunction(comp)) { + const extendProps = (raw) => { + hasExtends = true; + const [props, keys] = normalizePropsOptions(raw, appContext, true); + extend(normalized, props); + if (keys) + needCastKeys.push(...keys); + }; + if (!asMixin && appContext.mixins.length) { + appContext.mixins.forEach(extendProps); + } + if (comp.extends) { + extendProps(comp.extends); + } + if (comp.mixins) { + comp.mixins.forEach(extendProps); + } + } + if (!raw && !hasExtends) { + cache.set(comp, EMPTY_ARR); + return EMPTY_ARR; + } + if (isArray(raw)) { + for (let i = 0; i < raw.length; i++) { + if ((process.env.NODE_ENV !== 'production') && !isString(raw[i])) { + warn(`props must be strings when using array syntax.`, raw[i]); + } + const normalizedKey = camelize(raw[i]); + if (validatePropName(normalizedKey)) { + normalized[normalizedKey] = EMPTY_OBJ; + } + } + } + else if (raw) { + if ((process.env.NODE_ENV !== 'production') && !isObject(raw)) { + warn(`invalid props options`, raw); + } + for (const key in raw) { + const normalizedKey = camelize(key); + if (validatePropName(normalizedKey)) { + const opt = raw[key]; + const prop = (normalized[normalizedKey] = + isArray(opt) || isFunction(opt) ? { type: opt } : opt); + if (prop) { + const booleanIndex = getTypeIndex(Boolean, prop.type); + const stringIndex = getTypeIndex(String, prop.type); + prop[0 /* shouldCast */] = booleanIndex > -1; + prop[1 /* shouldCastTrue */] = + stringIndex < 0 || booleanIndex < stringIndex; + // if the prop needs boolean casting or default value + if (booleanIndex > -1 || hasOwn(prop, 'default')) { + needCastKeys.push(normalizedKey); + } + } + } + } + } + const res = [normalized, needCastKeys]; + cache.set(comp, res); + return res; +} +function validatePropName(key) { + if (key[0] !== '$') { + return true; + } + else if ((process.env.NODE_ENV !== 'production')) { + warn(`Invalid prop name: "${key}" is a reserved property.`); + } + return false; +} +// use function string name to check type constructors +// so that it works across vms / iframes. +function getType(ctor) { + const match = ctor && ctor.toString().match(/^\s*function (\w+)/); + return match ? match[1] : ''; +} +function isSameType(a, b) { + return getType(a) === getType(b); +} +function getTypeIndex(type, expectedTypes) { + if (isArray(expectedTypes)) { + return expectedTypes.findIndex(t => isSameType(t, type)); + } + else if (isFunction(expectedTypes)) { + return isSameType(expectedTypes, type) ? 0 : -1; + } + return -1; +} +/** + * dev only + */ +function validateProps(rawProps, props, instance) { + const resolvedValues = toRaw(props); + const options = instance.propsOptions[0]; + for (const key in options) { + let opt = options[key]; + if (opt == null) + continue; + validateProp(key, resolvedValues[key], opt, !hasOwn(rawProps, key) && !hasOwn(rawProps, hyphenate(key))); + } +} +/** + * dev only + */ +function validateProp(name, value, prop, isAbsent) { + const { type, required, validator } = prop; + // required! + if (required && isAbsent) { + warn('Missing required prop: "' + name + '"'); + return; + } + // missing but optional + if (value == null && !prop.required) { + return; + } + // type check + if (type != null && type !== true) { + let isValid = false; + const types = isArray(type) ? type : [type]; + const expectedTypes = []; + // value is valid as long as one of the specified types match + for (let i = 0; i < types.length && !isValid; i++) { + const { valid, expectedType } = assertType(value, types[i]); + expectedTypes.push(expectedType || ''); + isValid = valid; + } + if (!isValid) { + warn(getInvalidTypeMessage(name, value, expectedTypes)); + return; + } + } + // custom validator + if (validator && !validator(value)) { + warn('Invalid prop: custom validator check failed for prop "' + name + '".'); + } +} +const isSimpleType = /*#__PURE__*/ makeMap('String,Number,Boolean,Function,Symbol,BigInt'); +/** + * dev only + */ +function assertType(value, type) { + let valid; + const expectedType = getType(type); + if (isSimpleType(expectedType)) { + const t = typeof value; + valid = t === expectedType.toLowerCase(); + // for primitive wrapper objects + if (!valid && t === 'object') { + valid = value instanceof type; + } + } + else if (expectedType === 'Object') { + valid = isObject(value); + } + else if (expectedType === 'Array') { + valid = isArray(value); + } + else { + valid = value instanceof type; + } + return { + valid, + expectedType + }; +} +/** + * dev only + */ +function getInvalidTypeMessage(name, value, expectedTypes) { + let message = `Invalid prop: type check failed for prop "${name}".` + + ` Expected ${expectedTypes.map(capitalize).join(', ')}`; + const expectedType = expectedTypes[0]; + const receivedType = toRawType(value); + const expectedValue = styleValue(value, expectedType); + const receivedValue = styleValue(value, receivedType); + // check if we need to specify expected value + if (expectedTypes.length === 1 && + isExplicable(expectedType) && + !isBoolean(expectedType, receivedType)) { + message += ` with value ${expectedValue}`; + } + message += `, got ${receivedType} `; + // check if we need to specify received value + if (isExplicable(receivedType)) { + message += `with value ${receivedValue}.`; + } + return message; +} +/** + * dev only + */ +function styleValue(value, type) { + if (type === 'String') { + return `"${value}"`; + } + else if (type === 'Number') { + return `${Number(value)}`; + } + else { + return `${value}`; + } +} +/** + * dev only + */ +function isExplicable(type) { + const explicitTypes = ['string', 'number', 'boolean']; + return explicitTypes.some(elem => type.toLowerCase() === elem); +} +/** + * dev only + */ +function isBoolean(...args) { + return args.some(elem => elem.toLowerCase() === 'boolean'); +} + +const isInternalKey = (key) => key[0] === '_' || key === '$stable'; +const normalizeSlotValue = (value) => isArray(value) + ? value.map(normalizeVNode) + : [normalizeVNode(value)]; +const normalizeSlot = (key, rawSlot, ctx) => { + const normalized = withCtx((props) => { + if ((process.env.NODE_ENV !== 'production') && currentInstance) { + warn(`Slot "${key}" invoked outside of the render function: ` + + `this will not track dependencies used in the slot. ` + + `Invoke the slot function inside the render function instead.`); + } + return normalizeSlotValue(rawSlot(props)); + }, ctx); + normalized._c = false; + return normalized; +}; +const normalizeObjectSlots = (rawSlots, slots, instance) => { + const ctx = rawSlots._ctx; + for (const key in rawSlots) { + if (isInternalKey(key)) + continue; + const value = rawSlots[key]; + if (isFunction(value)) { + slots[key] = normalizeSlot(key, value, ctx); + } + else if (value != null) { + if ((process.env.NODE_ENV !== 'production') && + !(false )) { + warn(`Non-function value encountered for slot "${key}". ` + + `Prefer function slots for better performance.`); + } + const normalized = normalizeSlotValue(value); + slots[key] = () => normalized; + } + } +}; +const normalizeVNodeSlots = (instance, children) => { + if ((process.env.NODE_ENV !== 'production') && + !isKeepAlive(instance.vnode) && + !(false )) { + warn(`Non-function value encountered for default slot. ` + + `Prefer function slots for better performance.`); + } + const normalized = normalizeSlotValue(children); + instance.slots.default = () => normalized; +}; +const initSlots = (instance, children) => { + if (instance.vnode.shapeFlag & 32 /* SLOTS_CHILDREN */) { + const type = children._; + if (type) { + // users can get the shallow readonly version of the slots object through `this.$slots`, + // we should avoid the proxy object polluting the slots of the internal instance + instance.slots = toRaw(children); + // make compiler marker non-enumerable + def(children, '_', type); + } + else { + normalizeObjectSlots(children, (instance.slots = {})); + } + } + else { + instance.slots = {}; + if (children) { + normalizeVNodeSlots(instance, children); + } + } + def(instance.slots, InternalObjectKey, 1); +}; +const updateSlots = (instance, children, optimized) => { + const { vnode, slots } = instance; + let needDeletionCheck = true; + let deletionComparisonTarget = EMPTY_OBJ; + if (vnode.shapeFlag & 32 /* SLOTS_CHILDREN */) { + const type = children._; + if (type) { + // compiled slots. + if ((process.env.NODE_ENV !== 'production') && isHmrUpdating) { + // Parent was HMR updated so slot content may have changed. + // force update slots and mark instance for hmr as well + extend(slots, children); + } + else if (optimized && type === 1 /* STABLE */) { + // compiled AND stable. + // no need to update, and skip stale slots removal. + needDeletionCheck = false; + } + else { + // compiled but dynamic (v-if/v-for on slots) - update slots, but skip + // normalization. + extend(slots, children); + // #2893 + // when rendering the optimized slots by manually written render function, + // we need to delete the `slots._` flag if necessary to make subsequent updates reliable, + // i.e. let the `renderSlot` create the bailed Fragment + if (!optimized && type === 1 /* STABLE */) { + delete slots._; + } + } + } + else { + needDeletionCheck = !children.$stable; + normalizeObjectSlots(children, slots); + } + deletionComparisonTarget = children; + } + else if (children) { + // non slot object children (direct value) passed to a component + normalizeVNodeSlots(instance, children); + deletionComparisonTarget = { default: 1 }; + } + // delete stale slots + if (needDeletionCheck) { + for (const key in slots) { + if (!isInternalKey(key) && !(key in deletionComparisonTarget)) { + delete slots[key]; + } + } + } +}; + +/** +Runtime helper for applying directives to a vnode. Example usage: + +const comp = resolveComponent('comp') +const foo = resolveDirective('foo') +const bar = resolveDirective('bar') + +return withDirectives(h(comp), [ + [foo, this.x], + [bar, this.y] +]) +*/ +const isBuiltInDirective = /*#__PURE__*/ makeMap('bind,cloak,else-if,else,for,html,if,model,on,once,pre,show,slot,text'); +function validateDirectiveName(name) { + if (isBuiltInDirective(name)) { + warn('Do not use built-in directive ids as custom directive id: ' + name); + } +} +/** + * Adds directives to a VNode. + */ +function withDirectives(vnode, directives) { + const internalInstance = currentRenderingInstance; + if (internalInstance === null) { + (process.env.NODE_ENV !== 'production') && warn(`withDirectives can only be used inside render functions.`); + return vnode; + } + const instance = internalInstance.proxy; + const bindings = vnode.dirs || (vnode.dirs = []); + for (let i = 0; i < directives.length; i++) { + let [dir, value, arg, modifiers = EMPTY_OBJ] = directives[i]; + if (isFunction(dir)) { + dir = { + mounted: dir, + updated: dir + }; + } + bindings.push({ + dir, + instance, + value, + oldValue: void 0, + arg, + modifiers + }); + } + return vnode; +} +function invokeDirectiveHook(vnode, prevVNode, instance, name) { + const bindings = vnode.dirs; + const oldBindings = prevVNode && prevVNode.dirs; + for (let i = 0; i < bindings.length; i++) { + const binding = bindings[i]; + if (oldBindings) { + binding.oldValue = oldBindings[i].value; + } + let hook = binding.dir[name]; + if (hook) { + // disable tracking inside all lifecycle hooks + // since they can potentially be called inside effects. + pauseTracking(); + callWithAsyncErrorHandling(hook, instance, 8 /* DIRECTIVE_HOOK */, [ + vnode.el, + binding, + vnode, + prevVNode + ]); + resetTracking(); + } + } +} + +function createAppContext() { + return { + app: null, + config: { + isNativeTag: NO, + performance: false, + globalProperties: {}, + optionMergeStrategies: {}, + errorHandler: undefined, + warnHandler: undefined, + compilerOptions: {} + }, + mixins: [], + components: {}, + directives: {}, + provides: Object.create(null), + optionsCache: new WeakMap(), + propsCache: new WeakMap(), + emitsCache: new WeakMap() + }; +} +let uid$1 = 0; +function createAppAPI(render, hydrate) { + return function createApp(rootComponent, rootProps = null) { + if (rootProps != null && !isObject(rootProps)) { + (process.env.NODE_ENV !== 'production') && warn(`root props passed to app.mount() must be an object.`); + rootProps = null; + } + const context = createAppContext(); + const installedPlugins = new Set(); + let isMounted = false; + const app = (context.app = { + _uid: uid$1++, + _component: rootComponent, + _props: rootProps, + _container: null, + _context: context, + _instance: null, + version, + get config() { + return context.config; + }, + set config(v) { + if ((process.env.NODE_ENV !== 'production')) { + warn(`app.config cannot be replaced. Modify individual options instead.`); + } + }, + use(plugin, ...options) { + if (installedPlugins.has(plugin)) { + (process.env.NODE_ENV !== 'production') && warn(`Plugin has already been applied to target app.`); + } + else if (plugin && isFunction(plugin.install)) { + installedPlugins.add(plugin); + plugin.install(app, ...options); + } + else if (isFunction(plugin)) { + installedPlugins.add(plugin); + plugin(app, ...options); + } + else if ((process.env.NODE_ENV !== 'production')) { + warn(`A plugin must either be a function or an object with an "install" ` + + `function.`); + } + return app; + }, + mixin(mixin) { + if (__VUE_OPTIONS_API__) { + if (!context.mixins.includes(mixin)) { + context.mixins.push(mixin); + } + else if ((process.env.NODE_ENV !== 'production')) { + warn('Mixin has already been applied to target app' + + (mixin.name ? `: ${mixin.name}` : '')); + } + } + else if ((process.env.NODE_ENV !== 'production')) { + warn('Mixins are only available in builds supporting Options API'); + } + return app; + }, + component(name, component) { + if ((process.env.NODE_ENV !== 'production')) { + validateComponentName(name, context.config); + } + if (!component) { + return context.components[name]; + } + if ((process.env.NODE_ENV !== 'production') && context.components[name]) { + warn(`Component "${name}" has already been registered in target app.`); + } + context.components[name] = component; + return app; + }, + directive(name, directive) { + if ((process.env.NODE_ENV !== 'production')) { + validateDirectiveName(name); + } + if (!directive) { + return context.directives[name]; + } + if ((process.env.NODE_ENV !== 'production') && context.directives[name]) { + warn(`Directive "${name}" has already been registered in target app.`); + } + context.directives[name] = directive; + return app; + }, + mount(rootContainer, isHydrate, isSVG) { + if (!isMounted) { + const vnode = createVNode(rootComponent, rootProps); + // store app context on the root VNode. + // this will be set on the root instance on initial mount. + vnode.appContext = context; + // HMR root reload + if ((process.env.NODE_ENV !== 'production')) { + context.reload = () => { + render(cloneVNode(vnode), rootContainer, isSVG); + }; + } + if (isHydrate && hydrate) { + hydrate(vnode, rootContainer); + } + else { + render(vnode, rootContainer, isSVG); + } + isMounted = true; + app._container = rootContainer; + rootContainer.__vue_app__ = app; + if ((process.env.NODE_ENV !== 'production') || __VUE_PROD_DEVTOOLS__) { + app._instance = vnode.component; + devtoolsInitApp(app, version); + } + return vnode.component.proxy; + } + else if ((process.env.NODE_ENV !== 'production')) { + warn(`App has already been mounted.\n` + + `If you want to remount the same app, move your app creation logic ` + + `into a factory function and create fresh app instances for each ` + + `mount - e.g. \`const createMyApp = () => createApp(App)\``); + } + }, + unmount() { + if (isMounted) { + render(null, app._container); + if ((process.env.NODE_ENV !== 'production') || __VUE_PROD_DEVTOOLS__) { + app._instance = null; + devtoolsUnmountApp(app); + } + delete app._container.__vue_app__; + } + else if ((process.env.NODE_ENV !== 'production')) { + warn(`Cannot unmount an app that is not mounted.`); + } + }, + provide(key, value) { + if ((process.env.NODE_ENV !== 'production') && key in context.provides) { + warn(`App already provides property with key "${String(key)}". ` + + `It will be overwritten with the new value.`); + } + // TypeScript doesn't allow symbols as index type + // https://github.com/Microsoft/TypeScript/issues/24587 + context.provides[key] = value; + return app; + } + }); + return app; + }; +} + +let hasMismatch = false; +const isSVGContainer = (container) => /svg/.test(container.namespaceURI) && container.tagName !== 'foreignObject'; +const isComment = (node) => node.nodeType === 8 /* COMMENT */; +// Note: hydration is DOM-specific +// But we have to place it in core due to tight coupling with core - splitting +// it out creates a ton of unnecessary complexity. +// Hydration also depends on some renderer internal logic which needs to be +// passed in via arguments. +function createHydrationFunctions(rendererInternals) { + const { mt: mountComponent, p: patch, o: { patchProp, nextSibling, parentNode, remove, insert, createComment } } = rendererInternals; + const hydrate = (vnode, container) => { + if ((process.env.NODE_ENV !== 'production') && !container.hasChildNodes()) { + warn(`Attempting to hydrate existing markup but container is empty. ` + + `Performing full mount instead.`); + patch(null, vnode, container); + return; + } + hasMismatch = false; + hydrateNode(container.firstChild, vnode, null, null, null); + flushPostFlushCbs(); + if (hasMismatch && !false) { + // this error should show up in production + console.error(`Hydration completed but contains mismatches.`); + } + }; + const hydrateNode = (node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized = false) => { + const isFragmentStart = isComment(node) && node.data === '['; + const onMismatch = () => handleMismatch(node, vnode, parentComponent, parentSuspense, slotScopeIds, isFragmentStart); + const { type, ref, shapeFlag } = vnode; + const domType = node.nodeType; + vnode.el = node; + let nextNode = null; + switch (type) { + case Text: + if (domType !== 3 /* TEXT */) { + nextNode = onMismatch(); + } + else { + if (node.data !== vnode.children) { + hasMismatch = true; + (process.env.NODE_ENV !== 'production') && + warn(`Hydration text mismatch:` + + `\n- Client: ${JSON.stringify(node.data)}` + + `\n- Server: ${JSON.stringify(vnode.children)}`); + node.data = vnode.children; + } + nextNode = nextSibling(node); + } + break; + case Comment$1: + if (domType !== 8 /* COMMENT */ || isFragmentStart) { + nextNode = onMismatch(); + } + else { + nextNode = nextSibling(node); + } + break; + case Static: + if (domType !== 1 /* ELEMENT */) { + nextNode = onMismatch(); + } + else { + // determine anchor, adopt content + nextNode = node; + // if the static vnode has its content stripped during build, + // adopt it from the server-rendered HTML. + const needToAdoptContent = !vnode.children.length; + for (let i = 0; i < vnode.staticCount; i++) { + if (needToAdoptContent) + vnode.children += nextNode.outerHTML; + if (i === vnode.staticCount - 1) { + vnode.anchor = nextNode; + } + nextNode = nextSibling(nextNode); + } + return nextNode; + } + break; + case Fragment: + if (!isFragmentStart) { + nextNode = onMismatch(); + } + else { + nextNode = hydrateFragment(node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized); + } + break; + default: + if (shapeFlag & 1 /* ELEMENT */) { + if (domType !== 1 /* ELEMENT */ || + vnode.type.toLowerCase() !== + node.tagName.toLowerCase()) { + nextNode = onMismatch(); + } + else { + nextNode = hydrateElement(node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized); + } + } + else if (shapeFlag & 6 /* COMPONENT */) { + // when setting up the render effect, if the initial vnode already + // has .el set, the component will perform hydration instead of mount + // on its sub-tree. + vnode.slotScopeIds = slotScopeIds; + const container = parentNode(node); + mountComponent(vnode, container, null, parentComponent, parentSuspense, isSVGContainer(container), optimized); + // component may be async, so in the case of fragments we cannot rely + // on component's rendered output to determine the end of the fragment + // instead, we do a lookahead to find the end anchor node. + nextNode = isFragmentStart + ? locateClosingAsyncAnchor(node) + : nextSibling(node); + // #3787 + // if component is async, it may get moved / unmounted before its + // inner component is loaded, so we need to give it a placeholder + // vnode that matches its adopted DOM. + if (isAsyncWrapper(vnode)) { + let subTree; + if (isFragmentStart) { + subTree = createVNode(Fragment); + subTree.anchor = nextNode + ? nextNode.previousSibling + : container.lastChild; + } + else { + subTree = + node.nodeType === 3 ? createTextVNode('') : createVNode('div'); + } + subTree.el = node; + vnode.component.subTree = subTree; + } + } + else if (shapeFlag & 64 /* TELEPORT */) { + if (domType !== 8 /* COMMENT */) { + nextNode = onMismatch(); + } + else { + nextNode = vnode.type.hydrate(node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized, rendererInternals, hydrateChildren); + } + } + else if (shapeFlag & 128 /* SUSPENSE */) { + nextNode = vnode.type.hydrate(node, vnode, parentComponent, parentSuspense, isSVGContainer(parentNode(node)), slotScopeIds, optimized, rendererInternals, hydrateNode); + } + else if ((process.env.NODE_ENV !== 'production')) { + warn('Invalid HostVNode type:', type, `(${typeof type})`); + } + } + if (ref != null) { + setRef(ref, null, parentSuspense, vnode); + } + return nextNode; + }; + const hydrateElement = (el, vnode, parentComponent, parentSuspense, slotScopeIds, optimized) => { + optimized = optimized || !!vnode.dynamicChildren; + const { props, patchFlag, shapeFlag, dirs } = vnode; + // skip props & children if this is hoisted static nodes + if (patchFlag !== -1 /* HOISTED */) { + if (dirs) { + invokeDirectiveHook(vnode, null, parentComponent, 'created'); + } + // props + if (props) { + if (!optimized || + (patchFlag & 16 /* FULL_PROPS */ || + patchFlag & 32 /* HYDRATE_EVENTS */)) { + for (const key in props) { + if (!isReservedProp(key) && isOn(key)) { + patchProp(el, key, null, props[key]); + } + } + } + else if (props.onClick) { + // Fast path for click listeners (which is most often) to avoid + // iterating through props. + patchProp(el, 'onClick', null, props.onClick); + } + } + // vnode / directive hooks + let vnodeHooks; + if ((vnodeHooks = props && props.onVnodeBeforeMount)) { + invokeVNodeHook(vnodeHooks, parentComponent, vnode); + } + if (dirs) { + invokeDirectiveHook(vnode, null, parentComponent, 'beforeMount'); + } + if ((vnodeHooks = props && props.onVnodeMounted) || dirs) { + queueEffectWithSuspense(() => { + vnodeHooks && invokeVNodeHook(vnodeHooks, parentComponent, vnode); + dirs && invokeDirectiveHook(vnode, null, parentComponent, 'mounted'); + }, parentSuspense); + } + // children + if (shapeFlag & 16 /* ARRAY_CHILDREN */ && + // skip if element has innerHTML / textContent + !(props && (props.innerHTML || props.textContent))) { + let next = hydrateChildren(el.firstChild, vnode, el, parentComponent, parentSuspense, slotScopeIds, optimized); + let hasWarned = false; + while (next) { + hasMismatch = true; + if ((process.env.NODE_ENV !== 'production') && !hasWarned) { + warn(`Hydration children mismatch in <${vnode.type}>: ` + + `server rendered element contains more child nodes than client vdom.`); + hasWarned = true; + } + // The SSRed DOM contains more nodes than it should. Remove them. + const cur = next; + next = next.nextSibling; + remove(cur); + } + } + else if (shapeFlag & 8 /* TEXT_CHILDREN */) { + if (el.textContent !== vnode.children) { + hasMismatch = true; + (process.env.NODE_ENV !== 'production') && + warn(`Hydration text content mismatch in <${vnode.type}>:\n` + + `- Client: ${el.textContent}\n` + + `- Server: ${vnode.children}`); + el.textContent = vnode.children; + } + } + } + return el.nextSibling; + }; + const hydrateChildren = (node, parentVNode, container, parentComponent, parentSuspense, slotScopeIds, optimized) => { + optimized = optimized || !!parentVNode.dynamicChildren; + const children = parentVNode.children; + const l = children.length; + let hasWarned = false; + for (let i = 0; i < l; i++) { + const vnode = optimized + ? children[i] + : (children[i] = normalizeVNode(children[i])); + if (node) { + node = hydrateNode(node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized); + } + else if (vnode.type === Text && !vnode.children) { + continue; + } + else { + hasMismatch = true; + if ((process.env.NODE_ENV !== 'production') && !hasWarned) { + warn(`Hydration children mismatch in <${container.tagName.toLowerCase()}>: ` + + `server rendered element contains fewer child nodes than client vdom.`); + hasWarned = true; + } + // the SSRed DOM didn't contain enough nodes. Mount the missing ones. + patch(null, vnode, container, null, parentComponent, parentSuspense, isSVGContainer(container), slotScopeIds); + } + } + return node; + }; + const hydrateFragment = (node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized) => { + const { slotScopeIds: fragmentSlotScopeIds } = vnode; + if (fragmentSlotScopeIds) { + slotScopeIds = slotScopeIds + ? slotScopeIds.concat(fragmentSlotScopeIds) + : fragmentSlotScopeIds; + } + const container = parentNode(node); + const next = hydrateChildren(nextSibling(node), vnode, container, parentComponent, parentSuspense, slotScopeIds, optimized); + if (next && isComment(next) && next.data === ']') { + return nextSibling((vnode.anchor = next)); + } + else { + // fragment didn't hydrate successfully, since we didn't get a end anchor + // back. This should have led to node/children mismatch warnings. + hasMismatch = true; + // since the anchor is missing, we need to create one and insert it + insert((vnode.anchor = createComment(`]`, container)), container, next); // fixed by xxxxxx + return next; + } + }; + const handleMismatch = (node, vnode, parentComponent, parentSuspense, slotScopeIds, isFragment) => { + hasMismatch = true; + (process.env.NODE_ENV !== 'production') && + warn(`Hydration node mismatch:\n- Client vnode:`, vnode.type, `\n- Server rendered DOM:`, node, node.nodeType === 3 /* TEXT */ + ? `(text)` + : isComment(node) && node.data === '[' + ? `(start of fragment)` + : ``); + vnode.el = null; + if (isFragment) { + // remove excessive fragment nodes + const end = locateClosingAsyncAnchor(node); + while (true) { + const next = nextSibling(node); + if (next && next !== end) { + remove(next); + } + else { + break; + } + } + } + const next = nextSibling(node); + const container = parentNode(node); + remove(node); + patch(null, vnode, container, next, parentComponent, parentSuspense, isSVGContainer(container), slotScopeIds); + return next; + }; + const locateClosingAsyncAnchor = (node) => { + let match = 0; + while (node) { + node = nextSibling(node); + if (node && isComment(node)) { + if (node.data === '[') + match++; + if (node.data === ']') { + if (match === 0) { + return nextSibling(node); + } + else { + match--; + } + } + } + } + return node; + }; + return [hydrate, hydrateNode]; +} + +let supported; +let perf; +function startMeasure(instance, type) { + if (instance.appContext.config.performance && isSupported()) { + perf.mark(`vue-${type}-${instance.uid}`); + } + if ((process.env.NODE_ENV !== 'production') || __VUE_PROD_DEVTOOLS__) { + devtoolsPerfStart(instance, type, supported ? perf.now() : Date.now()); + } +} +function endMeasure(instance, type) { + if (instance.appContext.config.performance && isSupported()) { + const startTag = `vue-${type}-${instance.uid}`; + const endTag = startTag + `:end`; + perf.mark(endTag); + perf.measure(`<${formatComponentName(instance, instance.type)}> ${type}`, startTag, endTag); + perf.clearMarks(startTag); + perf.clearMarks(endTag); + } + if ((process.env.NODE_ENV !== 'production') || __VUE_PROD_DEVTOOLS__) { + devtoolsPerfEnd(instance, type, supported ? perf.now() : Date.now()); + } +} +function isSupported() { + if (supported !== undefined) { + return supported; + } + /* eslint-disable no-restricted-globals */ + if (typeof window !== 'undefined' && window.performance) { + supported = true; + perf = window.performance; + } + else { + supported = false; + } + /* eslint-enable no-restricted-globals */ + return supported; +} + +/** + * This is only called in esm-bundler builds. + * It is called when a renderer is created, in `baseCreateRenderer` so that + * importing runtime-core is side-effects free. + * + * istanbul-ignore-next + */ +function initFeatureFlags() { + let needWarn = false; + if (typeof __VUE_OPTIONS_API__ !== 'boolean') { + needWarn = true; + getGlobalThis().__VUE_OPTIONS_API__ = true; + } + if (typeof __VUE_PROD_DEVTOOLS__ !== 'boolean') { + needWarn = true; + getGlobalThis().__VUE_PROD_DEVTOOLS__ = false; + } + if ((process.env.NODE_ENV !== 'production') && needWarn) { + console.warn(`You are running the esm-bundler build of Vue. It is recommended to ` + + `configure your bundler to explicitly replace feature flag globals ` + + `with boolean literals to get proper tree-shaking in the final bundle. ` + + `See http://link.vuejs.org/feature-flags for more details.`); + } +} + +const prodEffectOptions = { + scheduler: queueJob, + // #1801, #2043 component render effects should allow recursive updates + allowRecurse: true +}; +function createDevEffectOptions(instance) { + return { + scheduler: queueJob, + allowRecurse: true, + onTrack: instance.rtc ? e => invokeArrayFns(instance.rtc, e) : void 0, + onTrigger: instance.rtg ? e => invokeArrayFns(instance.rtg, e) : void 0 + }; +} +const queuePostRenderEffect = queueEffectWithSuspense + ; +const setRef = (rawRef, oldRawRef, parentSuspense, vnode, isUnmount = false) => { + if (isArray(rawRef)) { + rawRef.forEach((r, i) => setRef(r, oldRawRef && (isArray(oldRawRef) ? oldRawRef[i] : oldRawRef), parentSuspense, vnode, isUnmount)); + return; + } + if (isAsyncWrapper(vnode) && !isUnmount) { + // when mounting async components, nothing needs to be done, + // because the template ref is forwarded to inner component + return; + } + const refValue = vnode.shapeFlag & 4 /* STATEFUL_COMPONENT */ + ? getExposeProxy(vnode.component) || vnode.component.proxy + : vnode.el; + const value = isUnmount ? null : refValue; + const { i: owner, r: ref } = rawRef; + if ((process.env.NODE_ENV !== 'production') && !owner) { + warn(`Missing ref owner context. ref cannot be used on hoisted vnodes. ` + + `A vnode with ref must be created inside the render function.`); + return; + } + const oldRef = oldRawRef && oldRawRef.r; + const refs = owner.refs === EMPTY_OBJ ? (owner.refs = {}) : owner.refs; + const setupState = owner.setupState; + // dynamic ref changed. unset old ref + if (oldRef != null && oldRef !== ref) { + if (isString(oldRef)) { + refs[oldRef] = null; + if (hasOwn(setupState, oldRef)) { + setupState[oldRef] = null; + } + } + else if (isRef(oldRef)) { + oldRef.value = null; + } + } + if (isString(ref)) { + const doSet = () => { + { + refs[ref] = value; + } + if (hasOwn(setupState, ref)) { + setupState[ref] = value; + } + }; + // #1789: for non-null values, set them after render + // null values means this is unmount and it should not overwrite another + // ref with the same key + if (value) { + doSet.id = -1; + queuePostRenderEffect(doSet, parentSuspense); + } + else { + doSet(); + } + } + else if (isRef(ref)) { + const doSet = () => { + ref.value = value; + }; + if (value) { + doSet.id = -1; + queuePostRenderEffect(doSet, parentSuspense); + } + else { + doSet(); + } + } + else if (isFunction(ref)) { + callWithErrorHandling(ref, owner, 12 /* FUNCTION_REF */, [value, refs]); + } + else if ((process.env.NODE_ENV !== 'production')) { + warn('Invalid template ref type:', value, `(${typeof value})`); + } +}; +/** + * The createRenderer function accepts two generic arguments: + * HostNode and HostElement, corresponding to Node and Element types in the + * host environment. For example, for runtime-dom, HostNode would be the DOM + * `Node` interface and HostElement would be the DOM `Element` interface. + * + * Custom renderers can pass in the platform specific types like this: + * + * ``` js + * const { render, createApp } = createRenderer({ + * patchProp, + * ...nodeOps + * }) + * ``` + */ +function createRenderer(options) { + return baseCreateRenderer(options); +} +// Separate API for creating hydration-enabled renderer. +// Hydration logic is only used when calling this function, making it +// tree-shakable. +function createHydrationRenderer(options) { + return baseCreateRenderer(options, createHydrationFunctions); +} +// implementation +function baseCreateRenderer(options, createHydrationFns) { + // compile-time feature flags check + { + initFeatureFlags(); + } + if ((process.env.NODE_ENV !== 'production') || __VUE_PROD_DEVTOOLS__) { + const target = getGlobalThis(); + target.__VUE__ = true; + setDevtoolsHook(target.__VUE_DEVTOOLS_GLOBAL_HOOK__); + } + const { insert: hostInsert, remove: hostRemove, patchProp: hostPatchProp, forcePatchProp: hostForcePatchProp, createElement: hostCreateElement, createText: hostCreateText, createComment: hostCreateComment, setText: hostSetText, setElementText: hostSetElementText, parentNode: hostParentNode, nextSibling: hostNextSibling, setScopeId: hostSetScopeId = NOOP, cloneNode: hostCloneNode, insertStaticContent: hostInsertStaticContent } = options; + // Note: functions inside this closure should use `const xxx = () => {}` + // style in order to prevent being inlined by minifiers. + const patch = (n1, n2, container, anchor = null, parentComponent = null, parentSuspense = null, isSVG = false, slotScopeIds = null, optimized = false) => { + // patching & not same type, unmount old tree + if (n1 && !isSameVNodeType(n1, n2)) { + anchor = getNextHostNode(n1); + unmount(n1, parentComponent, parentSuspense, true); + n1 = null; + } + if (n2.patchFlag === -2 /* BAIL */) { + optimized = false; + n2.dynamicChildren = null; + } + const { type, ref, shapeFlag } = n2; + switch (type) { + case Text: + processText(n1, n2, container, anchor); + break; + case Comment$1: + processCommentNode(n1, n2, container, anchor); + break; + case Static: + if (n1 == null) { + mountStaticNode(n2, container, anchor, isSVG); + } + else if ((process.env.NODE_ENV !== 'production')) { + patchStaticNode(n1, n2, container, isSVG); + } + break; + case Fragment: + processFragment(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized); + break; + default: + if (shapeFlag & 1 /* ELEMENT */) { + processElement(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized); + } + else if (shapeFlag & 6 /* COMPONENT */) { + processComponent(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized); + } + else if (shapeFlag & 64 /* TELEPORT */) { + type.process(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, internals); + } + else if (shapeFlag & 128 /* SUSPENSE */) { + type.process(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, internals); + } + else if ((process.env.NODE_ENV !== 'production')) { + warn('Invalid VNode type:', type, `(${typeof type})`); + } + } + // set ref + if (ref != null && parentComponent) { + setRef(ref, n1 && n1.ref, parentSuspense, n2 || n1, !n2); + } + }; + const processText = (n1, n2, container, anchor) => { + if (n1 == null) { + hostInsert((n2.el = hostCreateText(n2.children, container)), // fixed by xxxxxx + container, anchor); + } + else { + const el = (n2.el = n1.el); + if (n2.children !== n1.children) { + hostSetText(el, n2.children); + } + } + }; + const processCommentNode = (n1, n2, container, anchor) => { + if (n1 == null) { + hostInsert((n2.el = hostCreateComment(n2.children || '', container)), // fixed by xxxxxx + container, anchor); + } + else { + // there's no support for dynamic comments + n2.el = n1.el; + } + }; + const mountStaticNode = (n2, container, anchor, isSVG) => { + [n2.el, n2.anchor] = hostInsertStaticContent(n2.children, container, anchor, isSVG, + // pass cached nodes if the static node is being mounted multiple times + // so that runtime-dom can simply cloneNode() instead of inserting new + // HTML + n2.el && [n2.el, n2.anchor]); + }; + /** + * Dev / HMR only + */ + const patchStaticNode = (n1, n2, container, isSVG) => { + // static nodes are only patched during dev for HMR + if (n2.children !== n1.children) { + const anchor = hostNextSibling(n1.anchor); + // remove existing + removeStaticNode(n1); + [n2.el, n2.anchor] = hostInsertStaticContent(n2.children, container, anchor, isSVG); + } + else { + n2.el = n1.el; + n2.anchor = n1.anchor; + } + }; + const moveStaticNode = ({ el, anchor }, container, nextSibling) => { + let next; + while (el && el !== anchor) { + next = hostNextSibling(el); + hostInsert(el, container, nextSibling); + el = next; + } + hostInsert(anchor, container, nextSibling); + }; + const removeStaticNode = ({ el, anchor }) => { + let next; + while (el && el !== anchor) { + next = hostNextSibling(el); + hostRemove(el); + el = next; + } + hostRemove(anchor); + }; + const processElement = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => { + isSVG = isSVG || n2.type === 'svg'; + if (n1 == null) { + mountElement(n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized); + } + else { + patchElement(n1, n2, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized); + } + }; + const mountElement = (vnode, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => { + let el; + let vnodeHook; + const { type, props, shapeFlag, transition, patchFlag, dirs } = vnode; + if (!(process.env.NODE_ENV !== 'production') && + vnode.el && + hostCloneNode !== undefined && + patchFlag === -1 /* HOISTED */) { + // If a vnode has non-null el, it means it's being reused. + // Only static vnodes can be reused, so its mounted DOM nodes should be + // exactly the same, and we can simply do a clone here. + // only do this in production since cloned trees cannot be HMR updated. + el = vnode.el = hostCloneNode(vnode.el); + } + else { + el = vnode.el = hostCreateElement( + // fixed by xxxxxx + vnode.type, container); + // mount children first, since some props may rely on child content + // being already rendered, e.g. `