From a73dcb4cf93acccc511da457e3b5bbf7f1cad3e1 Mon Sep 17 00:00:00 2001 From: akimyou Date: Mon, 21 Sep 2020 10:14:20 +0800 Subject: [PATCH] update create-snowpack-app snap --- .../create-snowpack-app.test.js.snap | 5410 ++++++++++++++++- 1 file changed, 5409 insertions(+), 1 deletion(-) diff --git a/test/create-snowpack-app/__snapshots__/create-snowpack-app.test.js.snap b/test/create-snowpack-app/__snapshots__/create-snowpack-app.test.js.snap index d52ca07a00..3b8cf5deab 100644 --- a/test/create-snowpack-app/__snapshots__/create-snowpack-app.test.js.snap +++ b/test/create-snowpack-app/__snapshots__/create-snowpack-app.test.js.snap @@ -9512,6 +9512,36 @@ function normalizeClass(value) { } return res.trim(); } +/** + * 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 (val instanceof Map) { + return { + [\`Map(\${val.size})\`]: [...val.entries()].reduce((entries, [key, val]) => { + entries[\`\${key} =>\`] = val; + return entries; + }, {}) + }; + } + else if (val instanceof Set) { + return { + [\`Set(\${val.size})\`]: [...val.values()] + }; + } + else if (isObject(val) && !isArray(val) && !isPlainObject(val)) { + return String(val); + } + return val; +}; const EMPTY_OBJ = {}; const EMPTY_ARR = []; const NOOP = () => { }; @@ -9544,6 +9574,7 @@ const toTypeString = (value) => objectToString.call(value); const toRawType = (value) => { return toTypeString(value).slice(8, -1); }; +const isPlainObject = (val) => toTypeString(val) === '[object Object]'; const isIntegerKey = (key) => isString(key) && key[0] !== '-' && '' + parseInt(key, 10) === key; const isReservedProp = /*#__PURE__*/ makeMap('key,ref,' + 'onVnodeBeforeMount,onVnodeMounted,' + @@ -10881,6 +10912,26 @@ function closeBlock() { blockStack.pop(); currentBlock = blockStack[blockStack.length - 1] || null; } +/** + * Create a block root vnode. Takes the same exact arguments as \`createVNode\`. + * A block root keeps track of dynamic nodes within the block in the + * \`dynamicChildren\` array. + * + * @private + */ +function createBlock(type, props, children, patchFlag, dynamicProps) { + const vnode = createVNode(type, props, children, patchFlag, dynamicProps, true /* isBlock: prevent a block from tracking itself */); + // save current block children on the block vnode + vnode.dynamicChildren = currentBlock || EMPTY_ARR; + // close block + closeBlock(); + // a block is always going to be patched, so track it as a child of its + // parent block + if ( currentBlock) { + currentBlock.push(vnode); + } + return vnode; +} function isVNode(value) { return value ? value.__v_isVNode === true : false; } @@ -14186,5 +14237,5362 @@ function normalizeContainer(container) { } return container; } -export { createApp };" +export { createApp, createBlock, createTextVNode, createVNode, openBlock, toDisplayString };" +`; + +exports[`create-snowpack-app app-template-vue-typescript: __snowpack__/env.js 1`] = `"export default {\\"MODE\\":\\"production\\",\\"NODE_ENV\\":\\"production\\"};"`; + +exports[`create-snowpack-app app-template-vue-typescript: _dist_/App.css 1`] = ` +" +.App { + text-align: center; +} +.App-header { + background-color: #f9f6f6; + color: #32485f; + min-height: 100vh; + display: flex; + flex-direction: column; + align-items: center; + justify-content: center; + font-size: calc(10px + 2vmin); +} +.App-link { + color: #00c185; +} +.App-logo { + height: 40vmin; + pointer-events: none; + margin-bottom: 1rem; + animation: App-logo-spin infinite 1.6s ease-in-out alternate; +} +.App-tsx { + display: flex; +} +.App-tsx > div { + margin-left: 30px; + font-size: 16px; +} +@keyframes App-logo-spin { +from { + transform: scale(1); +} +to { + transform: scale(1.06); +} +}" +`; + +exports[`create-snowpack-app app-template-vue-typescript: _dist_/App.css.proxy.js 1`] = ` +" +const code = \\".App { text-align: center;}.App-header { background-color: #f9f6f6; color: #32485f; min-height: 100vh; display: flex; flex-direction: column; align-items: center; justify-content: center; font-size: calc(10px + 2vmin);}.App-link { color: #00c185;}.App-logo { height: 40vmin; pointer-events: none; margin-bottom: 1rem; animation: App-logo-spin infinite 1.6s ease-in-out alternate;}.App-tsx { display: flex;}.App-tsx > div { margin-left: 30px; font-size: 16px;}@keyframes App-logo-spin {from { transform: scale(1);}to { transform: scale(1.06);}}\\"; +const styleEl = document.createElement(\\"style\\"); +const codeEl = document.createTextNode(code); +styleEl.type = 'text/css'; +styleEl.appendChild(codeEl); +document.head.appendChild(styleEl);" +`; + +exports[`create-snowpack-app app-template-vue-typescript: _dist_/App.js 1`] = ` +"import './App.css.proxy.js'; +import {defineComponent, reactive} from \\"../web_modules/vue.js\\"; +import FooTsxVue from \\"./components/FooTsx.js\\"; +import FooTsx2 from \\"./components/Foo.js\\"; +import BarJsxVue from \\"./components/BarJsx.js\\"; +import BarJsx2 from \\"./components/Bar.js\\"; +const defaultExport = defineComponent({ + components: { + FooTsxVue, + FooTsx: FooTsx2, + BarJsxVue, + BarJsx: BarJsx2 + }, + setup() { + const state = reactive({ + message: \\"Learn Vue\\" + }); + return { + state + }; + } +}); +import { createVNode as _createVNode, createTextVNode as _createTextVNode, resolveComponent as _resolveComponent, toDisplayString as _toDisplayString, openBlock as _openBlock, createBlock as _createBlock } from \\"../web_modules/vue.js\\" +const _hoisted_1 = { class: \\"App\\" } +const _hoisted_2 = { class: \\"App-header\\" } +const _hoisted_3 = /*#__PURE__*/_createVNode(\\"img\\", { + src: \\"/logo.svg\\", + class: \\"App-logo\\", + alt: \\"logo\\" +}, null, -1) +const _hoisted_4 = /*#__PURE__*/_createVNode(\\"p\\", null, [ + /*#__PURE__*/_createTextVNode(\\" Edit \\"), + /*#__PURE__*/_createVNode(\\"code\\", null, \\"src/App.vue\\"), + /*#__PURE__*/_createTextVNode(\\" and save to reload. \\") +], -1) +const _hoisted_5 = { class: \\"App-tsx\\" } +const _hoisted_6 = { + class: \\"App-link\\", + href: \\"https://vuejs.org\\", + target: \\"_blank\\", + rel: \\"noopener noreferrer\\" +} +export function render(_ctx, _cache) { + const _component_FooTsxVue = _resolveComponent(\\"FooTsxVue\\") + const _component_FooTsx = _resolveComponent(\\"FooTsx\\") + const _component_BarJsxVue = _resolveComponent(\\"BarJsxVue\\") + const _component_BarJsx = _resolveComponent(\\"BarJsx\\") + return (_openBlock(), _createBlock(\\"div\\", _hoisted_1, [ + _createVNode(\\"header\\", _hoisted_2, [ + _hoisted_3, + _hoisted_4, + _createVNode(\\"p\\", _hoisted_5, [ + _createVNode(_component_FooTsxVue), + _createVNode(_component_FooTsx), + _createVNode(_component_BarJsxVue), + _createVNode(_component_BarJsx) + ]), + _createVNode(\\"a\\", _hoisted_6, _toDisplayString(_ctx.state.message), 1) + ]) + ])) +} +defaultExport.render = render +export default defaultExport" +`; + +exports[`create-snowpack-app app-template-vue-typescript: _dist_/components/Bar.js 1`] = ` +"import { Fragment } from '../../web_modules/vue.js'; +import {createVNode, isVNode} from '../../web_modules/vue.js'; +const slice = Array.prototype.slice; +export function jsx(tag, props = null, children = null) { + if (arguments.length > 3 || isVNode(children)) { + children = slice.call(arguments, 2); + } + return createVNode(tag, props, children); +} +import {defineComponent, reactive} from \\"../../web_modules/vue.js\\"; +import styles from \\"./Bar.module.css.proxy.js\\"; +export default defineComponent({ + name: \\"BarJsx\\", + setup() { + const state = reactive({ + name: \\"BarJsx\\" + }); + return () => /* @__PURE__ */ jsx(Fragment, null, /* @__PURE__ */ jsx(\\"div\\", { + className: styles[\\"bar-jsx\\"] + }, state.name)); + } +});" +`; + +exports[`create-snowpack-app app-template-vue-typescript: _dist_/components/Bar.module.css 1`] = ` +".bar-jsx { + color: red; +}" +`; + +exports[`create-snowpack-app app-template-vue-typescript: _dist_/components/Bar.module.css.proxy.js 1`] = ` +" +export let code = \\"._dist_components_Bar_module__bar-jsx { color: red;}\\"; +let json = {\\"bar-jsx\\":\\"_dist_components_Bar_module__bar-jsx\\"}; +export default json; +const styleEl = document.createElement(\\"style\\"); +const codeEl = document.createTextNode(code); +styleEl.type = 'text/css'; +styleEl.appendChild(codeEl); +document.head.appendChild(styleEl);" +`; + +exports[`create-snowpack-app app-template-vue-typescript: _dist_/components/BarJsx.css 1`] = ` +" +.bar-jsx-vue { + color: red; +}" +`; + +exports[`create-snowpack-app app-template-vue-typescript: _dist_/components/BarJsx.css.proxy.js 1`] = ` +" +const code = \\"/* unsupport scoped css in vue with tsx, jsx*/.bar-jsx-vue { color: red;}\\"; +const styleEl = document.createElement(\\"style\\"); +const codeEl = document.createTextNode(code); +styleEl.type = 'text/css'; +styleEl.appendChild(codeEl); +document.head.appendChild(styleEl);" +`; + +exports[`create-snowpack-app app-template-vue-typescript: _dist_/components/BarJsx.js 1`] = ` +"import './BarJsx.css.proxy.js'; +import { Fragment } from '../../web_modules/vue.js'; +import {createVNode, isVNode} from '../../web_modules/vue.js'; +const slice = Array.prototype.slice; +export function jsx(tag, props = null, children = null) { + if (arguments.length > 3 || isVNode(children)) { + children = slice.call(arguments, 2); + } + return createVNode(tag, props, children); +} +import {defineComponent, reactive} from \\"../../web_modules/vue.js\\"; +export default defineComponent({ + name: \\"BarJsxVue\\", + setup() { + const state = reactive({ + name: \\"BarJsxVue\\" + }); + return () => /* @__PURE__ */ jsx(Fragment, null, /* @__PURE__ */ jsx(\\"div\\", { + className: \\"bar-jsx-vue\\" + }, state.name)); + } +});" +`; + +exports[`create-snowpack-app app-template-vue-typescript: _dist_/components/Foo.js 1`] = ` +"import { Fragment } from '../../web_modules/vue.js'; +import {createVNode, isVNode} from '../../web_modules/vue.js'; +const slice = Array.prototype.slice; +export function jsx(tag, props = null, children = null) { + if (arguments.length > 3 || isVNode(children)) { + children = slice.call(arguments, 2); + } + return createVNode(tag, props, children); +} +import {defineComponent, reactive} from \\"../../web_modules/vue.js\\"; +import styles from \\"./Foo.module.css.proxy.js\\"; +export default defineComponent({ + name: \\"FooTsx\\", + setup() { + const state = reactive({ + name: \\"FooTsx\\" + }); + return () => /* @__PURE__ */ jsx(Fragment, null, /* @__PURE__ */ jsx(\\"div\\", { + className: styles[\\"foo-tsx\\"] + }, state.name)); + } +});" +`; + +exports[`create-snowpack-app app-template-vue-typescript: _dist_/components/Foo.module.css 1`] = ` +".foo-tsx { + color: green; +}" +`; + +exports[`create-snowpack-app app-template-vue-typescript: _dist_/components/Foo.module.css.proxy.js 1`] = ` +" +export let code = \\"._dist_components_Foo_module__foo-tsx { color: green;}\\"; +let json = {\\"foo-tsx\\":\\"_dist_components_Foo_module__foo-tsx\\"}; +export default json; +const styleEl = document.createElement(\\"style\\"); +const codeEl = document.createTextNode(code); +styleEl.type = 'text/css'; +styleEl.appendChild(codeEl); +document.head.appendChild(styleEl);" +`; + +exports[`create-snowpack-app app-template-vue-typescript: _dist_/components/FooTsx.css 1`] = ` +" +.foo-tsx-vue { + color: green; +}" +`; + +exports[`create-snowpack-app app-template-vue-typescript: _dist_/components/FooTsx.css.proxy.js 1`] = ` +" +const code = \\"/* unsupport scoped css in vue with tsx, jsx*/.foo-tsx-vue { color: green;}\\"; +const styleEl = document.createElement(\\"style\\"); +const codeEl = document.createTextNode(code); +styleEl.type = 'text/css'; +styleEl.appendChild(codeEl); +document.head.appendChild(styleEl);" +`; + +exports[`create-snowpack-app app-template-vue-typescript: _dist_/components/FooTsx.js 1`] = ` +"import './FooTsx.css.proxy.js'; +import { Fragment } from '../../web_modules/vue.js'; +import {createVNode, isVNode} from '../../web_modules/vue.js'; +const slice = Array.prototype.slice; +export function jsx(tag, props = null, children = null) { + if (arguments.length > 3 || isVNode(children)) { + children = slice.call(arguments, 2); + } + return createVNode(tag, props, children); +} +import {defineComponent, reactive} from \\"../../web_modules/vue.js\\"; +export default defineComponent({ + name: \\"FooTsxVue\\", + setup() { + const state = reactive({ + name: \\"FooTsxVue\\" + }); + return () => /* @__PURE__ */ jsx(Fragment, null, /* @__PURE__ */ jsx(\\"div\\", { + className: \\"foo-tsx-vue\\" + }, state.name)); + } +});" +`; + +exports[`create-snowpack-app app-template-vue-typescript: _dist_/index.js 1`] = ` +"import __SNOWPACK_ENV__ from '../__snowpack__/env.js'; +import.meta.env = __SNOWPACK_ENV__; +import { createApp } from \\"../web_modules/vue.js\\"; +import App from \\"./App.js\\"; +const app = createApp(App); +app.mount(\\"#app\\"); +// Hot Module Replacement (HMR) - Remove this snippet to remove HMR. +// Learn more: https://www.snowpack.dev/#hot-module-replacement +if (import.meta.hot) { + import.meta.hot.accept(); + import.meta.hot.dispose(() => { + app.unmount(); + }); +}" +`; + +exports[`create-snowpack-app app-template-vue-typescript: allFiles 1`] = ` +Array [ + "__snowpack__/env.js", + "_dist_/App.css", + "_dist_/App.css.proxy.js", + "_dist_/App.js", + "_dist_/components/Bar.js", + "_dist_/components/Bar.module.css", + "_dist_/components/Bar.module.css.proxy.js", + "_dist_/components/BarJsx.css", + "_dist_/components/BarJsx.css.proxy.js", + "_dist_/components/BarJsx.js", + "_dist_/components/Foo.js", + "_dist_/components/Foo.module.css", + "_dist_/components/Foo.module.css.proxy.js", + "_dist_/components/FooTsx.css", + "_dist_/components/FooTsx.css.proxy.js", + "_dist_/components/FooTsx.js", + "_dist_/index.js", + "favicon-32x32.png", + "favicon.ico", + "index.html", + "logo.svg", + "robots.txt", + "web_modules/import-map.json", + "web_modules/vue.js", +] +`; + +exports[`create-snowpack-app app-template-vue-typescript: index.html 1`] = ` +" + + + + + + + Snowpack App + + +
+ + + + +" +`; + +exports[`create-snowpack-app app-template-vue-typescript: web_modules/import-map.json 1`] = ` +"{ + \\"imports\\": { + \\"vue\\": \\"./vue.js\\" + } +}" +`; + +exports[`create-snowpack-app app-template-vue-typescript: web_modules/vue.js 1`] = ` +"/** + * 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'; +const isGloballyWhitelisted = /*#__PURE__*/ makeMap(GLOBALS_WHITE_LISTED); +/** + * On the client we only need to offer special cases for boolean attributes that + * have different names from their corresponding dom properties: + * - itemscope -> N/A + * - allowfullscreen -> allowFullscreen + * - formnovalidate -> formNoValidate + * - ismap -> isMap + * - nomodule -> noModule + * - novalidate -> noValidate + * - readonly -> readOnly + */ +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(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++) { + res += normalizeClass(value[i]) + ' '; + } + } + else if (isObject(value)) { + for (const name in value) { + if (value[name]) { + res += name + ' '; + } + } + } + return res.trim(); +} +/** + * 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 = {}; +const EMPTY_ARR = []; +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) => { + 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('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) => { + return str.replace(hyphenateRE, '-$1').toLowerCase(); +}); +/** + * @private + */ +const capitalize = cacheStringFunction((str) => { + return str.charAt(0).toUpperCase() + str.slice(1); +}); +// 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 + }); +}; +let _globalThis; +const getGlobalThis = () => { + return (_globalThis || + (_globalThis = + typeof globalThis !== 'undefined' + ? globalThis + : typeof self !== 'undefined' + ? self + : typeof window !== 'undefined' + ? window + : typeof global !== 'undefined' + ? global + : {})); +}; +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 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 options.scheduler ? undefined : 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._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); + } +} +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.options.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 (effect.options.scheduler) { + effect.options.scheduler(effect); + } + else { + effect(); + } + }; + effects.forEach(run); +} +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); + enableTracking(); + 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 ? readonlyMap : reactiveMap).get(target)) { + return target; + } + const targetIsArray = isArray(target); + if (targetIsArray && hasOwn(arrayInstrumentations, key)) { + return Reflect.get(arrayInstrumentations, key, receiver); + } + const res = Reflect.get(target, key, receiver); + const keyIsSymbol = isSymbol(key); + if (keyIsSymbol + ? builtInSymbols.has(key) + : key === \`__proto__\` || key === \`__v_isRef\`) { + 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) { + const oldValue = target[key]; + if (!shallow) { + value = toRaw(value); + 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); + } + } + 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); + } + 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 */, 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({}, 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 = isReadonly ? toReadonly : isShallow ? toShallow : toReactive; + if (has.call(rawTarget, key)) { + return wrap(target.get(key)); + } + else if (has.call(rawTarget, rawKey)) { + return wrap(target.get(rawKey)); + } +} +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); + const result = target.add(value); + if (!hadKey) { + trigger(target, \\"add\\" /* ADD */, value, value); + } + return result; +} +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); + } + const oldValue = get.call(target, key); + const result = target.set(key, value); + if (!hadKey) { + trigger(target, \\"add\\" /* ADD */, key, value); + } + else if (hasChanged(value, oldValue)) { + trigger(target, \\"set\\" /* SET */, key, value); + } + return result; +} +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); + } + 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); + } + return result; +} +function clear() { + const target = toRaw(this); + const hadItems = target.size !== 0; + // forward the operation before queueing reactions + const result = target.clear(); + if (hadItems) { + trigger(target, \\"clear\\" /* CLEAR */, undefined, undefined); + } + 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 = isReadonly ? toReadonly : isShallow ? toShallow : 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 = isReadonly ? toReadonly : isShallow ? toShallow : 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) { + 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 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); +}); +function createInstrumentationGetter(isReadonly, shallow) { + const instrumentations = shallow + ? 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 reactiveMap = new WeakMap(); +const readonlyMap = 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); +} +// Return a reactive-copy of the original object, where only the root level +// properties are reactive, and does NOT unwrap refs nor recursively convert +// returned properties. +function shallowReactive(target) { + return createReactiveObject(target, false, shallowReactiveHandlers, shallowCollectionHandlers); +} +function readonly(target) { + return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers); +} +function createReactiveObject(target, isReadonly, baseHandlers, collectionHandlers) { + if (!isObject(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 proxyMap = isReadonly ? readonlyMap : reactiveMap; + 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 isRef(r) { + return Boolean(r && r.__v_isRef === true); +} +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 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() { + if (this._dirty) { + this._value = this.effect(); + this._dirty = false; + } + track(toRaw(this), \\"get\\" /* GET */, 'value'); + return this._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) { + // 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(''), + trace + ]); + } + else { + const warnArgs = [\`[Vue warn]: \${msg}\`, ...args]; + if (trace.length && + // avoid spamming console during tests + !false) { + warnArgs.push(\`\`, ...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; +} +function formatTrace(trace) { + const logs = []; + trace.forEach((entry, i) => { + logs.push(...(i === 0 ? [] : [\`\`]), ...formatTraceEntry(entry)); + }); + return logs; +} +function formatTraceEntry({ vnode, recurseCount }) { + const postfix = recurseCount > 0 ? \`... (\${recurseCount} recursive calls)\` : \`\`; + const isRoot = vnode.component ? vnode.component.parent == null : false; + const open = \` at <\${formatComponentName(vnode.component, vnode.type, isRoot)}\`; + const close = \`>\` + postfix; + return vnode.props + ? [open, ...formatProps(vnode.props), close] + : [open + close]; +} +function formatProps(props) { + const res = []; + const keys = Object.keys(props); + keys.slice(0, 3).forEach(key => { + res.push(...formatProp(key, props[key])); + }); + if (keys.length > 3) { + res.push(\` ...\`); + } + return res; +} +function formatProp(key, value, raw) { + if (isString(value)) { + value = JSON.stringify(value); + return raw ? value : [\`\${key}=\${value}\`]; + } + else if (typeof value === 'number' || + typeof value === 'boolean' || + value == null) { + return raw ? value : [\`\${key}=\${value}\`]; + } + else if (isRef(value)) { + value = formatProp(key, toRaw(value.value), true); + return raw ? value : [\`\${key}=Ref<\`, value, \`>\`]; + } + else if (isFunction(value)) { + return [\`\${key}=fn\${value.name ? \`<\${value.name}>\` : \`\`}\`]; + } + else { + value = toRaw(value); + return raw ? value : [\`\${key}=\`, value]; + } +} +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 = type; + while (cur) { + const errorCapturedHooks = cur.ec; + if (errorCapturedHooks) { + for (let i = 0; i < errorCapturedHooks.length; i++) { + if (errorCapturedHooks[i](err, exposedInstance, errorInfo)) { + 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) { + { + // 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(fn) : p; +} +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) { + 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 > -1) { + queue[i] = null; + } +} +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; + for (preFlushIndex = 0; preFlushIndex < activePreFlushCbs.length; preFlushIndex++) { + 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; + 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); + // 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. + // Jobs can never be null before flush starts, since they are only invalidated + // during execution of another flushed job. + queue.sort((a, b) => getId(a) - getId(b)); + try { + for (flushIndex = 0; flushIndex < queue.length; flushIndex++) { + const job = queue[flushIndex]; + if (job) { + if ((\\"production\\" !== 'production')) ; + callWithErrorHandling(job, null, 14 /* SCHEDULER */); + } + } + } + finally { + flushIndex = 0; + queue.length = 0; + flushPostFlushCbs(); + isFlushing = false; + currentFlushPromise = null; + // some postFlushCb queued jobs! + // keep flushing until it drains. + if (queue.length || pendingPostFlushCbs.length) { + flushJobs(seen); + } + } +} +function checkRecursiveUpdates(seen, fn) { + if (!seen.has(fn)) { + seen.set(fn, 1); + } + else { + const count = seen.get(fn); + if (count > RECURSION_LIMIT) { + throw new Error(\`Maximum recursive updates exceeded. \` + + \`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.\`); + } + else { + seen.set(fn, count + 1); + } + } +} +function emit(instance, event, ...args) { + const props = instance.vnode.props || EMPTY_OBJ; + if ( __VUE_PROD_DEVTOOLS__) ; + let handlerName = \`on\${capitalize(event)}\`; + let handler = props[handlerName]; + // for v-model update:xxx events, also trigger kebab-case equivalent + // for props passed via kebab-case + if (!handler && event.startsWith('update:')) { + handlerName = \`on\${capitalize(hyphenate(event))}\`; + handler = props[handlerName]; + } + if (!handler) { + handler = props[handlerName + \`Once\`]; + if (!instance.emitted) { + (instance.emitted = {})[handlerName] = true; + } + else if (instance.emitted[handlerName]) { + return; + } + } + if (handler) { + callWithAsyncErrorHandling(handler, instance, 6 /* COMPONENT_EVENT_HANDLER */, args); + } +} +function normalizeEmitsOptions(comp, appContext, asMixin = false) { + const appId = appContext.app ? appContext.app._uid : -1; + const cache = comp.__emits || (comp.__emits = {}); + const cached = cache[appId]; + 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) => { + hasExtends = true; + extend(normalized, normalizeEmitsOptions(raw, appContext, true)); + }; + 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) { + return (cache[appId] = null); + } + if (isArray(raw)) { + raw.forEach(key => (normalized[key] = null)); + } + else { + extend(normalized, raw); + } + return (cache[appId] = 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.replace(/Once$/, ''); + return (hasOwn(options, key[2].toLowerCase() + key.slice(3)) || + hasOwn(options, key.slice(2))); +} +// mark the current rendering instance for asset resolution (e.g. +// resolveComponent, resolveDirective) during render +let currentRenderingInstance = null; +function setCurrentRenderingInstance(instance) { + currentRenderingInstance = instance; +} +// 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 } = instance; + let result; + currentRenderingInstance = instance; + 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 ((\\"production\\" !== 'production') && attrs === props) ; + result = normalizeVNode(render.length > 1 + ? render(props, (\\"production\\" !== '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 ((\\"production\\" !== 'production')) ; + if (Component.inheritAttrs !== false && fallthroughAttrs) { + 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 ((\\"production\\" !== 'production') && !accessedAttrs && root.type !== Comment) ; + } + } + // inherit directives + if (vnode.dirs) { + if ((\\"production\\" !== 'production') && !isElementRoot(root)) ; + root.dirs = vnode.dirs; + } + // inherit transition data + if (vnode.transition) { + if ((\\"production\\" !== 'production') && !isElementRoot(root)) ; + root.transition = vnode.transition; + } + if ((\\"production\\" !== 'production') && setRoot) ; + else { + result = root; + } + } + catch (err) { + handleError(err, instance, 1 /* RENDER_FUNCTION */); + result = createVNode(Comment); + } + currentRenderingInstance = null; + 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) => { + if (vnode.type !== Fragment) { + return [vnode, undefined]; + } + 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 (dynamicIndex > -1) { + dynamicChildren[dynamicIndex] = updatedRoot; + } + else if (dynamicChildren && updatedRoot.patchFlag > 0) { + dynamicChildren.push(updatedRoot); + } + }; + return [normalizeVNode(childRoot), setRoot]; +}; +/** + * dev only + */ +function filterSingleRoot(children) { + const filtered = children.filter(child => { + return !(isVNode(child) && + child.type === Comment && + child.children !== 'v-if'); + }); + return filtered.length === 1 && isVNode(filtered[0]) ? filtered[0] : null; +} +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 // 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; + // 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; +function normalizeSuspenseChildren(vnode) { + const { shapeFlag, children } = vnode; + let content; + let fallback; + if (shapeFlag & 32 /* SLOTS_CHILDREN */) { + content = normalizeSuspenseSlot(children.default); + fallback = normalizeSuspenseSlot(children.fallback); + } + else { + content = normalizeSuspenseSlot(children); + fallback = normalizeVNode(null); + } + return { + content, + fallback + }; +} +function normalizeSuspenseSlot(s) { + if (isFunction(s)) { + s = s(); + } + if (isArray(s)) { + const singleChild = filterSingleRoot(s); + s = singleChild; + } + return normalizeVNode(s); +} +function queueEffectWithSuspense(fn, suspense) { + if (suspense && suspense.pendingBranch) { + if (isArray(fn)) { + suspense.effects.push(...fn); + } + else { + suspense.effects.push(fn); + } + } + else { + queuePostFlushCb(fn); + } +} +let isRenderingCompiledSlot = 0; +const setCompiledSlotRendering = (n) => (isRenderingCompiledSlot += n); +/** + * Wrap a slot function to memoize current rendering instance + * @private + */ +function withCtx(fn, ctx = currentRenderingInstance) { + if (!ctx) + 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 need to push a null block to + // avoid that. This isn't necessary if rendering a compiled \`\`. + if (!isRenderingCompiledSlot) { + openBlock(true /* null block that disables tracking */); + } + const owner = currentRenderingInstance; + setCurrentRenderingInstance(ctx); + const res = fn(...args); + setCurrentRenderingInstance(owner); + if (!isRenderingCompiledSlot) { + closeBlock(); + } + return res; + }; + renderFnWithContext._c = true; + return renderFnWithContext; +} +// SFC scoped style ID management. +let currentScopeId = null; +const isTeleport = (type) => type.__isTeleport; +const COMPONENTS = 'components'; +/** + * @private + */ +function resolveComponent(name) { + return resolveAsset(COMPONENTS, name) || name; +} +const NULL_DYNAMIC_COMPONENT = Symbol(); +// implementation +function resolveAsset(type, name, warnMissing = true) { + const instance = currentRenderingInstance || currentInstance; + if (instance) { + const Component = instance.type; + // self name has highest priority + if (type === COMPONENTS) { + const selfName = Component.displayName || Component.name; + if (selfName && + (selfName === name || + selfName === camelize(name) || + selfName === capitalize(camelize(name)))) { + return Component; + } + } + const res = + // local registration + // check instance[type] first for components with mixin or extends. + resolve(instance[type] || Component[type], name) || + // global registration + resolve(instance.appContext[type], name); + return res; + } +} +function resolve(registry, name) { + return (registry && + (registry[name] || + registry[camelize(name)] || + registry[capitalize(camelize(name))])); +} +const Fragment = Symbol( undefined); +const Text = Symbol( undefined); +const Comment = Symbol( undefined); +const Static = Symbol( undefined); +// Since v-if and v-for are the two possible ways node structure can dynamically +// change, once we consider v-if branches and each v-for fragment a block, we +// can divide a template into nested blocks, and within each block the node +// structure would be stable. This allows us to skip most children diffing +// and only worry about the dynamic nodes (indicated by patch flags). +const blockStack = []; +let currentBlock = null; +/** + * Open a block. + * This must be called before \`createBlock\`. It cannot be part of \`createBlock\` + * because the children of the block are evaluated before \`createBlock\` itself + * is called. The generated code typically looks like this: + * + * \`\`\`js + * function render() { + * return (openBlock(),createBlock('div', null, [...])) + * } + * \`\`\` + * disableTracking is true when creating a v-for fragment block, since a v-for + * fragment always diffs its children. + * + * @private + */ +function openBlock(disableTracking = false) { + blockStack.push((currentBlock = disableTracking ? null : [])); +} +function closeBlock() { + blockStack.pop(); + currentBlock = blockStack[blockStack.length - 1] || null; +} +/** + * Create a block root vnode. Takes the same exact arguments as \`createVNode\`. + * A block root keeps track of dynamic nodes within the block in the + * \`dynamicChildren\` array. + * + * @private + */ +function createBlock(type, props, children, patchFlag, dynamicProps) { + const vnode = createVNode(type, props, children, patchFlag, dynamicProps, true /* isBlock: prevent a block from tracking itself */); + // save current block children on the block vnode + vnode.dynamicChildren = currentBlock || EMPTY_ARR; + // close block + closeBlock(); + // a block is always going to be patched, so track it as a child of its + // parent block + if ( currentBlock) { + currentBlock.push(vnode); + } + return vnode; +} +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 }) => { + return (ref != null + ? isArray(ref) + ? ref + : { i: currentRenderingInstance, r: ref } + : null); +}; +const createVNode = ( _createVNode); +function _createVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, isBlockNode = false) { + if (!type || type === NULL_DYNAMIC_COMPONENT) { + type = Comment; + } + if (isVNode(type)) { + // createVNode receiving an existing vnode. This happens in cases like + // + // #2078 make sure to merge refs during the clone instead of overwriting it + const cloned = cloneVNode(type, props, true /* mergeRef: true */); + if (children) { + normalizeChildren(cloned, children); + } + return cloned; + } + // class component normalization. + if (isClassComponent(type)) { + type = type.__vccOpts; + } + // class & style normalization. + if (props) { + // for reactive or proxy objects, we need to clone it to enable mutation. + if (isProxy(props) || InternalObjectKey in props) { + props = extend({}, props); + } + let { class: klass, style } = props; + if (klass && !isString(klass)) { + props.class = normalizeClass(klass); + } + if (isObject(style)) { + // reactive state objects need to be cloned since they are likely to be + // mutated + if (isProxy(style) && !isArray(style)) { + style = extend({}, style); + } + props.style = normalizeStyle(style); + } + } + // encode the vnode type information into a bitmap + const shapeFlag = isString(type) + ? 1 /* ELEMENT */ + : isSuspense(type) + ? 128 /* SUSPENSE */ + : isTeleport(type) + ? 64 /* TELEPORT */ + : isObject(type) + ? 4 /* STATEFUL_COMPONENT */ + : isFunction(type) + ? 2 /* FUNCTIONAL_COMPONENT */ + : 0; + const vnode = { + __v_isVNode: true, + [\\"__v_skip\\" /* SKIP */]: true, + type, + props, + key: props && normalizeKey(props), + ref: props && normalizeRef(props), + scopeId: currentScopeId, + 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); + // normalize suspense children + if ( shapeFlag & 128 /* SUSPENSE */) { + const { content, fallback } = normalizeSuspenseChildren(vnode); + vnode.ssContent = content; + vnode.ssFallback = fallback; + } + if ( + // avoid a block node from tracking itself + !isBlockNode && + // has current parent block + currentBlock && + // presence of a patch flag indicates this node needs patching on updates. + // component nodes also should always be patched, because even if the + // component doesn't need to update, it needs to persist the instance on to + // the next vnode so that it can be properly unmounted later. + (patchFlag > 0 || shapeFlag & 6 /* COMPONENT */) && + // the EVENTS flag is only for hydration and if it is the only flag, the + // vnode should not be considered dynamic due to handler caching. + patchFlag !== 32 /* HYDRATE_EVENTS */) { + currentBlock.push(vnode); + } + return vnode; +} +function cloneVNode(vnode, extraProps, mergeRef = false) { + // This is intentionally NOT using spread or extend to avoid the runtime + // key enumeration cost. + const { props, ref, patchFlag } = vnode; + const mergedProps = extraProps ? mergeProps(props || {}, extraProps) : props; + return { + __v_isVNode: true, + [\\"__v_skip\\" /* SKIP */]: true, + type: vnode.type, + props: mergedProps, + key: mergedProps && normalizeKey(mergedProps), + ref: extraProps && extraProps.ref + ? // #2078 in the case of + // if the vnode itself already has a ref, cloneVNode will need to merge + // the refs so the single vnode can be set on multiple refs + mergeRef && ref + ? isArray(ref) + ? ref.concat(normalizeRef(extraProps)) + : [ref, normalizeRef(extraProps)] + : normalizeRef(extraProps) + : ref, + scopeId: vnode.scopeId, + children: vnode.children, + target: vnode.target, + targetAnchor: vnode.targetAnchor, + staticCount: vnode.staticCount, + shapeFlag: vnode.shapeFlag, + // if the vnode is cloned with extra props, we can no longer assume its + // existing patch flag to be reliable and need to add the FULL_PROPS flag. + // note: perserve flag for fragments since they use the flag for children + // fast paths only. + patchFlag: extraProps && vnode.type !== Fragment + ? patchFlag === -1 // hoisted node + ? 16 /* FULL_PROPS */ + : patchFlag | 16 /* FULL_PROPS */ + : patchFlag, + dynamicProps: vnode.dynamicProps, + dynamicChildren: vnode.dynamicChildren, + appContext: vnode.appContext, + dirs: vnode.dirs, + transition: vnode.transition, + // These should technically only be non-null on mounted VNodes. However, + // they *should* be copied for kept-alive vnodes. So we just always copy + // them since them being non-null during a mount doesn't affect the logic as + // they will simply be overwritten. + component: vnode.component, + suspense: vnode.suspense, + ssContent: vnode.ssContent && cloneVNode(vnode.ssContent), + ssFallback: vnode.ssFallback && cloneVNode(vnode.ssFallback), + el: vnode.el, + anchor: vnode.anchor + }; +} +/** + * @private + */ +function createTextVNode(text = ' ', flag = 0) { + return createVNode(Text, null, text, flag); +} +function normalizeVNode(child) { + if (child == null || typeof child === 'boolean') { + // empty placeholder + return createVNode(Comment); + } + else if (isArray(child)) { + // fragment + return createVNode(Fragment, null, child); + } + else if (typeof child === 'object') { + // already vnode, this should be the most common since compiled templates + // always produce all-vnode children arrays + return child.el === null ? child : cloneVNode(child); + } + else { + // strings and numbers + return createVNode(Text, null, String(child)); + } +} +// optimized normalization for template-compiled render fns +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 /* ARRAY_CHILDREN */; + } + else if (typeof children === 'object') { + if (shapeFlag & 1 /* ELEMENT */ || shapeFlag & 64 /* TELEPORT */) { + // Normalize slot to plain children for plain element and Teleport + const slot = children.default; + if (slot) { + // _c marker is added by withCtx() indicating this is a compiled slot + slot._c && setCompiledSlotRendering(1); + normalizeChildren(vnode, slot()); + slot._c && setCompiledSlotRendering(-1); + } + return; + } + else { + type = 32 /* SLOTS_CHILDREN */; + const slotFlag = children._; + if (!slotFlag && !(InternalObjectKey in children)) { + children._ctx = currentRenderingInstance; + } + else if (slotFlag === 3 /* FORWARDED */ && currentRenderingInstance) { + // a child component receives forwarded slots from the parent. + // its slot type is determined by its parent's slot type. + if (currentRenderingInstance.vnode.patchFlag & 1024 /* DYNAMIC_SLOTS */) { + children._ = 2 /* DYNAMIC */; + vnode.patchFlag |= 1024 /* DYNAMIC_SLOTS */; + } + else { + children._ = 1 /* STABLE */; + } + } + } + } + else if (isFunction(children)) { + children = { default: children, _ctx: currentRenderingInstance }; + type = 32 /* SLOTS_CHILDREN */; + } + else { + children = String(children); + // force teleport children to array so it can be moved around + if (shapeFlag & 64 /* TELEPORT */) { + type = 16 /* ARRAY_CHILDREN */; + children = [createTextVNode(children)]; + } + else { + type = 8 /* TEXT_CHILDREN */; + } + } + vnode.children = children; + vnode.shapeFlag |= type; +} +function mergeProps(...args) { + const ret = extend({}, 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, toMerge[key]) + : incoming; + } + } + else { + ret[key] = toMerge[key]; + } + } + } + return ret; +} +function initProps(instance, rawProps, isStateful, // result of bitwise flag comparison +isSSR = false) { + const props = {}; + const attrs = {}; + def(attrs, InternalObjectKey, 1); + setFullProps(instance, rawProps, props, attrs); + 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; + if ( + // always force full diff if hmr is enabled + (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++) { + const 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)) { + attrs[key] = value; + } + else { + const camelizedKey = camelize(key); + props[camelizedKey] = resolvePropValue(options, rawCurrentProps, camelizedKey, value, instance); + } + } + else { + attrs[key] = value; + } + } + } + } + else { + // full props update. + setFullProps(instance, rawProps, props, attrs); + // 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, rawProps || EMPTY_OBJ, key, undefined, instance); + } + } + 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]; + } + } + } + } + // trigger updates for $attrs in case it's used in component slots + trigger(instance, \\"set\\" /* SET */, '$attrs'); +} +function setFullProps(instance, rawProps, props, attrs) { + const [options, needCastKeys] = instance.propsOptions; + if (rawProps) { + for (const key in rawProps) { + const value = rawProps[key]; + // key, ref are reserved and never passed down + if (isReservedProp(key)) { + continue; + } + // 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)))) { + props[camelKey] = value; + } + else if (!isEmitListener(instance.emitsOptions, key)) { + // Any non-declared (either as a prop or an emitted event) props are put + // into a separate \`attrs\` object for spreading. Make sure to preserve + // original key casing + attrs[key] = value; + } + } + } + if (needCastKeys) { + const rawCurrentProps = toRaw(props); + for (let i = 0; i < needCastKeys.length; i++) { + const key = needCastKeys[i]; + props[key] = resolvePropValue(options, rawCurrentProps, key, rawCurrentProps[key], instance); + } + } +} +function resolvePropValue(options, props, key, value, instance) { + 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)) { + setCurrentInstance(instance); + value = defaultValue(props); + setCurrentInstance(null); + } + else { + value = defaultValue; + } + } + // boolean casting + if (opt[0 /* shouldCast */]) { + if (!hasOwn(props, key) && !hasDefault) { + value = false; + } + else if (opt[1 /* shouldCastTrue */] && + (value === '' || value === hyphenate(key))) { + value = true; + } + } + } + return value; +} +function normalizePropsOptions(comp, appContext, asMixin = false) { + const appId = appContext.app ? appContext.app._uid : -1; + const cache = comp.__props || (comp.__props = {}); + const cached = cache[appId]; + 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) { + return (cache[appId] = 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 /* 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); + } + } + } + } + } + return (cache[appId] = [normalized, needCastKeys]); +} +// 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)) { + for (let i = 0, len = expectedTypes.length; i < len; i++) { + if (isSameType(expectedTypes[i], type)) { + return i; + } + } + } + else if (isFunction(expectedTypes)) { + return isSameType(expectedTypes, type) ? 0 : -1; + } + return -1; +} +/** + * dev only + */ +function validatePropName(key) { + if (key[0] !== '$') { + return true; + } + return false; +} +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; + } +} +const createHook = (lifecycle) => (hook, target = currentInstance) => +// post-create lifecycle registrations are noops during SSR +!isInSSRComponentSetup && 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 onRenderTriggered = createHook(\\"rtg\\" /* RENDER_TRIGGERED */); +const onRenderTracked = createHook(\\"rtc\\" /* RENDER_TRACKED */); +const onErrorCaptured = (hook, target = currentInstance) => { + injectHook(\\"ec\\" /* ERROR_CAPTURED */, hook, target); +}; +const isKeepAlive = (vnode) => vnode.type.__isKeepAlive; +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); +} +const isInternalKey = (key) => key[0] === '_' || key === '$stable'; +const normalizeSlotValue = (value) => isArray(value) + ? value.map(normalizeVNode) + : [normalizeVNode(value)]; +const normalizeSlot = (key, rawSlot, ctx) => withCtx((props) => { + return normalizeSlotValue(rawSlot(props)); +}, ctx); +const normalizeObjectSlots = (rawSlots, slots) => { + 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 /* SLOTS_CHILDREN */) { + const type = children._; + if (type) { + instance.slots = 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) => { + 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 (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); + } + } + 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]; + } + } + } +}; +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; + } + const hook = binding.dir[name]; + if (hook) { + callWithAsyncErrorHandling(hook, instance, 8 /* DIRECTIVE_HOOK */, [ + vnode.el, + binding, + vnode, + prevVNode + ]); + } + } +} +function createAppContext() { + return { + app: null, + config: { + isNativeTag: NO, + performance: false, + globalProperties: {}, + optionMergeStrategies: {}, + isCustomElement: NO, + errorHandler: undefined, + warnHandler: undefined + }, + mixins: [], + components: {}, + directives: {}, + provides: Object.create(null) + }; +} +let uid$1 = 0; +function createAppAPI(render, hydrate) { + return function createApp(rootComponent, rootProps = null) { + if (rootProps != null && !isObject(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, + 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 (__VUE_OPTIONS_API__) { + 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) { + 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; + if (isHydrate && hydrate) { + hydrate(vnode, rootContainer); + } + else { + render(vnode, rootContainer); + } + isMounted = true; + app._container = rootContainer; + rootContainer.__vue_app__ = app; + if ( __VUE_PROD_DEVTOOLS__) ; + return vnode.component.proxy; + } + }, + unmount() { + if (isMounted) { + render(null, app._container); + if ( __VUE_PROD_DEVTOOLS__) ; + } + }, + provide(key, value) { + // TypeScript doesn't allow symbols as index type + // https://github.com/Microsoft/TypeScript/issues/24587 + context.provides[key] = value; + return app; + } + }); + return app; + }; +} +/** + * 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() { + if (typeof __VUE_OPTIONS_API__ !== 'boolean') { + getGlobalThis().__VUE_OPTIONS_API__ = true; + } + if (typeof __VUE_PROD_DEVTOOLS__ !== 'boolean') { + getGlobalThis().__VUE_PROD_DEVTOOLS__ = false; + } +} +const prodEffectOptions = { + scheduler: queueJob, + // #1801, #2043 component render effects should allow recursive updates + allowRecurse: true +}; +const queuePostRenderEffect = queueEffectWithSuspense + ; +const setRef = (rawRef, oldRawRef, parentComponent, parentSuspense, vnode) => { + if (isArray(rawRef)) { + rawRef.forEach((r, i) => setRef(r, oldRawRef && (isArray(oldRawRef) ? oldRawRef[i] : oldRawRef), parentComponent, parentSuspense, vnode)); + return; + } + let value; + if (!vnode) { + value = null; + } + else { + if (vnode.shapeFlag & 4 /* STATEFUL_COMPONENT */) { + value = vnode.component.proxy; + } + else { + value = vnode.el; + } + } + const { i: owner, r: ref } = rawRef; + const oldRef = oldRawRef && oldRawRef.r; + const refs = owner.refs === EMPTY_OBJ ? (owner.refs = {}) : owner.refs; + const setupState = owner.setupState; + // 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, parentComponent, 12 /* FUNCTION_REF */, [ + value, + refs + ]); + } + else ; +}; +/** + * 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); +} +// implementation +function baseCreateRenderer(options, createHydrationFns) { + // compile-time feature flags check + { + initFeatureFlags(); + } + 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, 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: + 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, optimized); + break; + default: + if (shapeFlag & 1 /* ELEMENT */) { + processElement(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized); + } + else if (shapeFlag & 6 /* COMPONENT */) { + processComponent(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized); + } + else if (shapeFlag & 64 /* TELEPORT */) { + type.process(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized, internals); + } + else if ( shapeFlag & 128 /* SUSPENSE */) { + type.process(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized, internals); + } + else ; + } + // set ref + if (ref != null && parentComponent) { + setRef(ref, n1 && n1.ref, parentComponent, parentSuspense, 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 { + // 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); + }; + const processElement = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized) => { + isSVG = isSVG || n2.type === 'svg'; + if (n1 == null) { + mountElement(n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized); + } + else { + patchElement(n1, n2, parentComponent, parentSuspense, isSVG, optimized); + } + }; + const mountElement = (vnode, container, anchor, parentComponent, parentSuspense, isSVG, optimized) => { + let el; + let vnodeHook; + const { type, props, shapeFlag, transition, scopeId, patchFlag, dirs } = vnode; + if ( + 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(vnode.type, isSVG, props && props.is); + // mount children first, since some props may rely on child content + // being already rendered, e.g. \`