From 27b37faa9744fe387aa62cbb3e2a322c3f8a1ea5 Mon Sep 17 00:00:00 2001 From: fxy060608 Date: Tue, 8 Feb 2022 14:56:45 +0800 Subject: [PATCH] wip(app): nvue --- packages/uni-app-vue/build.json | 36 +- .../uni-app-vue/dist/nvue.runtime.esm.dev.js | 17550 ++++++-------- .../uni-app-vue/dist/nvue.runtime.esm.prod.js | 14782 +++++------- .../dist/service.runtime.esm.dev.js | 19914 +++++++--------- .../dist/service.runtime.esm.prod.js | 17026 ++++++------- packages/uni-app-vue/lib/nvue.runtime.esm.js | 1358 +- .../uni-app-vue/lib/service.runtime.esm.js | 1367 +- 7 files changed, 31816 insertions(+), 40217 deletions(-) diff --git a/packages/uni-app-vue/build.json b/packages/uni-app-vue/build.json index 5d0c5dc2e4..c130500995 100644 --- a/packages/uni-app-vue/build.json +++ b/packages/uni-app-vue/build.json @@ -6,14 +6,19 @@ "output": { "freeze": false, "banner": "export function vueFactory (exports) {\n", - "footer": "}" + "footer": "}", + "format": "iife", + "globals": { + "@vue/shared": "exports.VueShared", + "@vue/reactivity": "exports.VueReactivity" + } }, "replacements": { "__VUE_OPTIONS_API__": "true", "__VUE_PROD_DEVTOOLS__": "false", "process.env.NODE_ENV": "\"development\"" }, - "external": false, + "external": ["@vue/shared", "@vue/reactivity"], "babel": true }, { @@ -23,14 +28,19 @@ "output": { "freeze": false, "banner": "export function vueFactory (exports) {\n", - "footer": "}" + "footer": "}", + "format": "iife", + "globals": { + "@vue/shared": "exports.VueShared", + "@vue/reactivity": "exports.VueReactivity" + } }, "replacements": { "__VUE_OPTIONS_API__": "true", "__VUE_PROD_DEVTOOLS__": "false", "process.env.NODE_ENV": "\"production\"" }, - "external": false, + "external": ["@vue/shared", "@vue/reactivity"], "babel": true }, { @@ -50,14 +60,19 @@ "output": { "freeze": false, "banner": "export function nvueFactory (exports, document) {\n", - "footer": "}" + "footer": "}", + "format": "iife", + "globals": { + "@vue/shared": "exports.VueShared", + "@vue/reactivity": "exports.VueReactivity" + } }, "replacements": { "__VUE_OPTIONS_API__": "true", "__VUE_PROD_DEVTOOLS__": "false", "process.env.NODE_ENV": "\"development\"" }, - "external": false, + "external": ["@vue/shared", "@vue/reactivity"], "babel": true }, { @@ -67,14 +82,19 @@ "output": { "freeze": false, "banner": "export function nvueFactory (exports, document) {\n", - "footer": "}" + "footer": "}", + "format": "iife", + "globals": { + "@vue/shared": "exports.VueShared", + "@vue/reactivity": "exports.VueReactivity" + } }, "replacements": { "__VUE_OPTIONS_API__": "true", "__VUE_PROD_DEVTOOLS__": "false", "process.env.NODE_ENV": "\"production\"" }, - "external": false, + "external": ["@vue/shared", "@vue/reactivity"], "babel": true } ] diff --git a/packages/uni-app-vue/dist/nvue.runtime.esm.dev.js b/packages/uni-app-vue/dist/nvue.runtime.esm.dev.js index 079de131cc..be8a4e9e52 100644 --- a/packages/uni-app-vue/dist/nvue.runtime.esm.dev.js +++ b/packages/uni-app-vue/dist/nvue.runtime.esm.dev.js @@ -1,11560 +1,9864 @@ -export function nvueFactory(exports, document) { - /** - * 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) { - var map = Object.create(null); - var list = str.split(','); - - for (var i = 0; i < list.length; i++) { - map[list[i]] = true; - } - - return expectsLowerCase ? val => !!map[val.toLowerCase()] : val => !!map[val]; - } - - var GLOBALS_WHITE_LISTED = 'Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,' + 'decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,' + 'Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt'; - var isGloballyWhitelisted = /*#__PURE__*/makeMap(GLOBALS_WHITE_LISTED); - - function normalizeStyle(value) { - if (isArray(value)) { - var res = {}; +"use strict"; - for (var i = 0; i < value.length; i++) { - var item = value[i]; - var normalized = isString(item) ? parseStringStyle(item) : normalizeStyle(item); +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.nvueFactory = nvueFactory; - if (normalized) { - for (var key in normalized) { - res[key] = normalized[key]; - } - } - } +function nvueFactory(exports, document) { + (function (shared, reactivity) { + 'use strict'; - return res; - } else if (isString(value)) { - return value; - } else if (isObject(value)) { - return value; + var stack = []; + + function pushWarningContext(vnode) { + stack.push(vnode); } - } - var listDelimiterRE = /;(?![^(]*\))/g; - var propertyDelimiterRE = /:(.+)/; + function popWarningContext() { + stack.pop(); + } - function parseStringStyle(cssText) { - var ret = {}; - cssText.split(listDelimiterRE).forEach(item => { - if (item) { - var tmp = item.split(propertyDelimiterRE); - tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim()); - } - }); - return ret; - } + function warn(msg) { + // avoid props formatting or warn handler tracking deps that might be mutated + // during patch, leading to infinite recursion. + reactivity.pauseTracking(); + var instance = stack.length ? stack[stack.length - 1].component : null; + var appWarnHandler = instance && instance.appContext.config.warnHandler; + var trace = getComponentTrace(); - function normalizeClass(value) { - var res = ''; + for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { + args[_key - 1] = arguments[_key]; + } - if (isString(value)) { - res = value; - } else if (isArray(value)) { - for (var i = 0; i < value.length; i++) { - var normalized = normalizeClass(value[i]); + if (appWarnHandler) { + callWithErrorHandling(appWarnHandler, instance, 11 + /* APP_WARN_HANDLER */ + , [msg + args.join(''), instance && instance.proxy, trace.map(_ref => { + var { + vnode + } = _ref; + return "at <".concat(formatComponentName(instance, vnode.type), ">"); + }).join('\n'), trace]); + } else { + var warnArgs = ["[Vue warn]: ".concat(msg), ...args]; + /* istanbul ignore if */ - if (normalized) { - res += normalized + ' '; - } - } - } else if (isObject(value)) { - for (var name in value) { - if (value[name]) { - res += name + ' '; + if (trace.length && // avoid spamming console during tests + !false) { + warnArgs.push("\n", ...formatTrace(trace)); } + + console.warn(...warnArgs); } + + reactivity.resetTracking(); } - return res.trim(); - } + function getComponentTrace() { + var currentVNode = stack[stack.length - 1]; - function normalizeProps(props) { - if (!props) return null; - var { - class: klass, - style - } = props; + 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. - if (klass && !isString(klass)) { - props.class = normalizeClass(klass); - } - if (style) { - props.style = normalizeStyle(style); - } + var normalizedStack = []; - return props; - } - /** - * For converting {{ interpolation }} values to displayed strings. - * @private - */ + while (currentVNode) { + var last = normalizedStack[0]; + if (last && last.vnode === currentVNode) { + last.recurseCount++; + } else { + normalizedStack.push({ + vnode: currentVNode, + recurseCount: 0 + }); + } - var toDisplayString = val => { - return isString(val) ? val : val == null ? '' : isArray(val) || isObject(val) && (val.toString === objectToString || !isFunction(val.toString)) ? JSON.stringify(val, replacer, 2) : String(val); - }; + var parentInstance = currentVNode.component && currentVNode.component.parent; + currentVNode = parentInstance && parentInstance.vnode; + } - var replacer = (_key, val) => { - // can't use isRef here since @vue/shared has no deps - if (val && val.__v_isRef) { - return replacer(_key, val.value); - } else if (isMap(val)) { - return { - ["Map(".concat(val.size, ")")]: [...val.entries()].reduce((entries, _ref) => { - var [key, val] = _ref; - entries["".concat(key, " =>")] = val; - return entries; - }, {}) - }; - } else if (isSet(val)) { - return { - ["Set(".concat(val.size, ")")]: [...val.values()] - }; - } else if (isObject(val) && !isArray(val) && !isPlainObject(val)) { - return String(val); + return normalizedStack; + } + /* istanbul ignore next */ + + + function formatTrace(trace) { + var logs = []; + trace.forEach((entry, i) => { + logs.push(...(i === 0 ? [] : ["\n"]), ...formatTraceEntry(entry)); + }); + return logs; } - return val; - }; + function formatTraceEntry(_ref2) { + var { + vnode, + recurseCount + } = _ref2; + var postfix = recurseCount > 0 ? "... (".concat(recurseCount, " recursive calls)") : ""; + var isRoot = vnode.component ? vnode.component.parent == null : false; + var open = " at <".concat(formatComponentName(vnode.component, vnode.type, isRoot)); + var close = ">" + postfix; + return vnode.props ? [open, ...formatProps(vnode.props), close] : [open + close]; + } + /* istanbul ignore next */ - var EMPTY_OBJ = Object.freeze({}); - var EMPTY_ARR = Object.freeze([]); - var NOOP = () => {}; - /** - * Always return false. - */ + function formatProps(props) { + var res = []; + var keys = Object.keys(props); + keys.slice(0, 3).forEach(key => { + res.push(...formatProp(key, props[key])); + }); + if (keys.length > 3) { + res.push(" ..."); + } - var NO = () => false; + return res; + } + /* istanbul ignore next */ - var onRE = /^on[^a-z]/; - var isOn = key => onRE.test(key); + function formatProp(key, value, raw) { + if (shared.isString(value)) { + value = JSON.stringify(value); + return raw ? value : ["".concat(key, "=").concat(value)]; + } else if (typeof value === 'number' || typeof value === 'boolean' || value == null) { + return raw ? value : ["".concat(key, "=").concat(value)]; + } else if (reactivity.isRef(value)) { + value = formatProp(key, reactivity.toRaw(value.value), true); + return raw ? value : ["".concat(key, "=Ref<"), value, ">"]; + } else if (shared.isFunction(value)) { + return ["".concat(key, "=fn").concat(value.name ? "<".concat(value.name, ">") : "")]; + } else { + value = reactivity.toRaw(value); + return raw ? value : ["".concat(key, "="), value]; + } + } - var isModelListener = key => key.startsWith('onUpdate:'); + var ErrorTypeStrings = { + ["sp" + /* SERVER_PREFETCH */ + ]: 'serverPrefetch hook', + ["bc" + /* BEFORE_CREATE */ + ]: 'beforeCreate hook', + ["c" + /* CREATED */ + ]: 'created hook', + ["bm" + /* BEFORE_MOUNT */ + ]: 'beforeMount hook', + ["m" + /* MOUNTED */ + ]: 'mounted hook', + ["bu" + /* BEFORE_UPDATE */ + ]: 'beforeUpdate hook', + ["u" + /* UPDATED */ + ]: 'updated', + ["bum" + /* BEFORE_UNMOUNT */ + ]: 'beforeUnmount hook', + ["um" + /* UNMOUNTED */ + ]: 'unmounted hook', + ["a" + /* ACTIVATED */ + ]: 'activated hook', + ["da" + /* DEACTIVATED */ + ]: 'deactivated hook', + ["ec" + /* ERROR_CAPTURED */ + ]: 'errorCaptured hook', + ["rtc" + /* RENDER_TRACKED */ + ]: 'renderTracked hook', + ["rtg" + /* RENDER_TRIGGERED */ + ]: 'renderTriggered hook', + [0 + /* SETUP_FUNCTION */ + ]: 'setup function', + [1 + /* RENDER_FUNCTION */ + ]: 'render function', + [2 + /* WATCH_GETTER */ + ]: 'watcher getter', + [3 + /* WATCH_CALLBACK */ + ]: 'watcher callback', + [4 + /* WATCH_CLEANUP */ + ]: 'watcher cleanup function', + [5 + /* NATIVE_EVENT_HANDLER */ + ]: 'native event handler', + [6 + /* COMPONENT_EVENT_HANDLER */ + ]: 'component event handler', + [7 + /* VNODE_HOOK */ + ]: 'vnode hook', + [8 + /* DIRECTIVE_HOOK */ + ]: 'directive hook', + [9 + /* TRANSITION_HOOK */ + ]: 'transition hook', + [10 + /* APP_ERROR_HANDLER */ + ]: 'app errorHandler', + [11 + /* APP_WARN_HANDLER */ + ]: 'app warnHandler', + [12 + /* FUNCTION_REF */ + ]: 'ref function', + [13 + /* ASYNC_COMPONENT_LOADER */ + ]: 'async component loader', + [14 + /* SCHEDULER */ + ]: 'scheduler flush. This is likely a Vue internals bug. ' + 'Please open an issue at https://new-issue.vuejs.org/?repo=vuejs/core' + }; - var extend = Object.assign; + function callWithErrorHandling(fn, instance, type, args) { + var res; - var remove = (arr, el) => { - var i = arr.indexOf(el); + try { + res = args ? fn(...args) : fn(); + } catch (err) { + handleError(err, instance, type); + } - if (i > -1) { - arr.splice(i, 1); + return res; } - }; - var hasOwnProperty = Object.prototype.hasOwnProperty; + function callWithAsyncErrorHandling(fn, instance, type, args) { + if (shared.isFunction(fn)) { + var res = callWithErrorHandling(fn, instance, type, args); + + if (res && shared.isPromise(res)) { + res.catch(err => { + handleError(err, instance, type); + }); + } + + return res; + } - var hasOwn = (val, key) => hasOwnProperty.call(val, key); + var values = []; - var isArray = Array.isArray; + for (var i = 0; i < fn.length; i++) { + values.push(callWithAsyncErrorHandling(fn[i], instance, type, args)); + } - var isMap = val => toTypeString(val) === '[object Map]'; + return values; + } - var isSet = val => toTypeString(val) === '[object Set]'; + function handleError(err, instance, type) { + var throwInDev = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true; + var contextVNode = instance ? instance.vnode : null; - var isFunction = val => typeof val === 'function'; + if (instance) { + var cur = instance.parent; // the exposed instance is the render proxy to keep it consistent with 2.x - var isString = val => typeof val === 'string'; + var exposedInstance = instance.proxy; // in production the hook receives only the error code + // fixed by xxxxxx - var isSymbol = val => typeof val === 'symbol'; + var errorInfo = ErrorTypeStrings[type] || type; - var isObject = val => val !== null && typeof val === 'object'; + while (cur) { + var errorCapturedHooks = cur.ec; - var isPromise = val => { - return isObject(val) && isFunction(val.then) && isFunction(val.catch); - }; + if (errorCapturedHooks) { + for (var i = 0; i < errorCapturedHooks.length; i++) { + if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) { + return; + } + } + } - var objectToString = Object.prototype.toString; + cur = cur.parent; + } // app-level handling - var toTypeString = value => objectToString.call(value); - var toRawType = value => { - // extract "RawType" from strings like "[object RawType]" - return toTypeString(value).slice(8, -1); - }; + var appErrorHandler = instance.appContext.config.errorHandler; - var isPlainObject = val => toTypeString(val) === '[object Object]'; + if (appErrorHandler) { + callWithErrorHandling(appErrorHandler, null, 10 + /* APP_ERROR_HANDLER */ + , [err, exposedInstance, errorInfo]); + return; + } + } - var isIntegerKey = key => isString(key) && key !== 'NaN' && key[0] !== '-' && '' + parseInt(key, 10) === key; + logError(err, type, contextVNode, throwInDev); + } - var isReservedProp = /*#__PURE__*/makeMap( // the leading comma is intentional so empty string "" is also included - ',key,ref,ref_for,ref_key,' + 'onVnodeBeforeMount,onVnodeMounted,' + 'onVnodeBeforeUpdate,onVnodeUpdated,' + 'onVnodeBeforeUnmount,onVnodeUnmounted'); - var isBuiltInDirective = /*#__PURE__*/makeMap('bind,cloak,else-if,else,for,html,if,model,on,once,pre,show,slot,text,memo'); + function logError(err, type, contextVNode) { + var throwInDev = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true; + { + var info = ErrorTypeStrings[type] || type; // fixed by xxxxxx - var cacheStringFunction = fn => { - var cache = Object.create(null); - return str => { - var hit = cache[str]; - return hit || (cache[str] = fn(str)); - }; - }; - - var camelizeRE = /-(\w)/g; - /** - * @private - */ - - var camelize = cacheStringFunction(str => { - return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : ''); - }); - var hyphenateRE = /\B([A-Z])/g; - /** - * @private - */ - - var hyphenate = cacheStringFunction(str => str.replace(hyphenateRE, '-$1').toLowerCase()); - /** - * @private - */ - - var capitalize = cacheStringFunction(str => str.charAt(0).toUpperCase() + str.slice(1)); - /** - * @private - */ - - var toHandlerKey = cacheStringFunction(str => str ? "on".concat(capitalize(str)) : ""); // compare whether a value has changed, accounting for NaN. - - var hasChanged = (value, oldValue) => !Object.is(value, oldValue); - - var invokeArrayFns = (fns, arg) => { - for (var i = 0; i < fns.length; i++) { - fns[i](arg); - } - }; - - var def = (obj, key, value) => { - Object.defineProperty(obj, key, { - configurable: true, - enumerable: false, - value - }); - }; + if (contextVNode) { + pushWarningContext(contextVNode); + } - var toNumber = val => { - var n = parseFloat(val); - return isNaN(n) ? val : n; - }; + warn("Unhandled error".concat(info ? " during execution of ".concat(info) : "")); - var _globalThis; + if (contextVNode) { + popWarningContext(); + } // crash in dev by default so it's more noticeable - var getGlobalThis = () => { - return _globalThis || (_globalThis = typeof globalThis !== 'undefined' ? globalThis : typeof self !== 'undefined' ? self : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : {}); - }; - function warn(msg) { - for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key2 = 1; _key2 < _len; _key2++) { - args[_key2 - 1] = arguments[_key2]; - } + if (throwInDev) { + throw err; + } else { + console.error(err); + } + } + } + + var isFlushing = false; + var isFlushPending = false; + var queue = []; + var flushIndex = 0; + var pendingPreFlushCbs = []; + var activePreFlushCbs = null; + var preFlushIndex = 0; + var pendingPostFlushCbs = []; + var activePostFlushCbs = null; + var postFlushIndex = 0; + var resolvedPromise = Promise.resolve(); + var currentFlushPromise = null; + var currentPreFlushParentJob = null; + var RECURSION_LIMIT = 100; + + function nextTick(fn) { + var p = currentFlushPromise || resolvedPromise; + return fn ? p.then(this ? fn.bind(this) : fn) : p; + } // #2768 + // Use binary-search to find a suitable position in the queue, + // so that the queue maintains the increasing order of job's id, + // which can prevent the job from being skipped and also can avoid repeated patching. + + + function findInsertionIndex(id) { + // the start index should be `flushIndex + 1` + var start = flushIndex + 1; + var end = queue.length; + + while (start < end) { + var middle = start + end >>> 1; + var middleJobId = getId(queue[middle]); + middleJobId < id ? start = middle + 1 : end = middle; + } + + return start; + } + + function queueJob(job) { + // the dedupe search uses the startIndex argument of Array.includes() + // by default the search index includes the current job that is being run + // so it cannot recursively trigger itself again. + // if the job is a watch() callback, the search will start with a +1 index to + // allow it recursively trigger itself - it is the user's responsibility to + // ensure it doesn't end up in an infinite loop. + if ((!queue.length || !queue.includes(job, isFlushing && job.allowRecurse ? flushIndex + 1 : flushIndex)) && job !== currentPreFlushParentJob) { + if (job.id == null) { + queue.push(job); + } else { + queue.splice(findInsertionIndex(job.id), 0, job); + } - console.warn("[Vue warn] ".concat(msg), ...args); - } + queueFlush(); + } + } - var activeEffectScope; + function queueFlush() { + if (!isFlushing && !isFlushPending) { + isFlushPending = true; + currentFlushPromise = resolvedPromise.then(flushJobs); + } + } - class EffectScope { - constructor() { - var detached = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; - this.active = true; - this.effects = []; - this.cleanups = []; + function invalidateJob(job) { + var i = queue.indexOf(job); - if (!detached && activeEffectScope) { - this.parent = activeEffectScope; - this.index = (activeEffectScope.scopes || (activeEffectScope.scopes = [])).push(this) - 1; + if (i > flushIndex) { + queue.splice(i, 1); } } - run(fn) { - if (this.active) { - try { - activeEffectScope = this; - return fn(); - } finally { - activeEffectScope = this.parent; + function queueCb(cb, activeQueue, pendingQueue, index) { + if (!shared.isArray(cb)) { + if (!activeQueue || !activeQueue.includes(cb, cb.allowRecurse ? index + 1 : index)) { + pendingQueue.push(cb); } } else { - warn("cannot run an inactive effect scope."); + // 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); } - } - on() { - activeEffectScope = this; + queueFlush(); } - off() { - activeEffectScope = this.parent; + function queuePreFlushCb(cb) { + queueCb(cb, activePreFlushCbs, pendingPreFlushCbs, preFlushIndex); } - stop(fromParent) { - if (this.active) { - var i, l; + function queuePostFlushCb(cb) { + queueCb(cb, activePostFlushCbs, pendingPostFlushCbs, postFlushIndex); + } - for (i = 0, l = this.effects.length; i < l; i++) { - this.effects[i].stop(); - } + function flushPreFlushCbs(seen) { + var parentJob = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null; - for (i = 0, l = this.cleanups.length; i < l; i++) { - this.cleanups[i](); + if (pendingPreFlushCbs.length) { + currentPreFlushParentJob = parentJob; + activePreFlushCbs = [...new Set(pendingPreFlushCbs)]; + pendingPreFlushCbs.length = 0; + { + seen = seen || new Map(); } - if (this.scopes) { - for (i = 0, l = this.scopes.length; i < l; i++) { - this.scopes[i].stop(true); + for (preFlushIndex = 0; preFlushIndex < activePreFlushCbs.length; preFlushIndex++) { + if (checkRecursiveUpdates(seen, activePreFlushCbs[preFlushIndex])) { + continue; } - } // nested scope, dereference from parent to avoid memory leaks - - if (this.parent && !fromParent) { - // optimized O(1) removal - var last = this.parent.scopes.pop(); - - if (last && last !== this) { - this.parent.scopes[this.index] = last; - last.index = this.index; - } + activePreFlushCbs[preFlushIndex](); } - this.active = false; + activePreFlushCbs = null; + preFlushIndex = 0; + currentPreFlushParentJob = null; // recursively flush until it drains + + flushPreFlushCbs(seen, parentJob); } } - } + function flushPostFlushCbs(seen) { + if (pendingPostFlushCbs.length) { + var deduped = [...new Set(pendingPostFlushCbs)]; + pendingPostFlushCbs.length = 0; // #1947 already has active queue, nested flushPostFlushCbs call - function effectScope(detached) { - return new EffectScope(detached); - } + if (activePostFlushCbs) { + activePostFlushCbs.push(...deduped); + return; + } - function recordEffectScope(effect) { - var scope = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : activeEffectScope; + activePostFlushCbs = deduped; + { + seen = seen || new Map(); + } + activePostFlushCbs.sort((a, b) => getId(a) - getId(b)); - if (scope && scope.active) { - scope.effects.push(effect); - } - } + for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) { + if (checkRecursiveUpdates(seen, activePostFlushCbs[postFlushIndex])) { + continue; + } - function getCurrentScope() { - return activeEffectScope; - } + activePostFlushCbs[postFlushIndex](); + } - function onScopeDispose(fn) { - if (activeEffectScope) { - activeEffectScope.cleanups.push(fn); - } else { - warn("onScopeDispose() is called when there is no active effect scope" + " to be associated with."); + activePostFlushCbs = null; + postFlushIndex = 0; + } } - } - var createDep = effects => { - var dep = new Set(effects); - dep.w = 0; - dep.n = 0; - return dep; - }; + var getId = job => job.id == null ? Infinity : job.id; - var wasTracked = dep => (dep.w & trackOpBit) > 0; + function flushJobs(seen) { + isFlushPending = false; + isFlushing = true; + { + seen = seen || new Map(); + } + flushPreFlushCbs(seen); // Sort queue before flush. + // This ensures that: + // 1. Components are updated from parent to child. (because parent is always + // created before the child so its render effect will have smaller + // priority number) + // 2. If a component is unmounted during a parent component's update, + // its update can be skipped. - var newTracked = dep => (dep.n & trackOpBit) > 0; + queue.sort((a, b) => getId(a) - getId(b)); // conditional usage of checkRecursiveUpdate must be determined out of + // try ... catch block since Rollup by default de-optimizes treeshaking + // inside try-catch. This can leave all warning code unshaked. Although + // they would get eventually shaken by a minifier like terser, some minifiers + // would fail to do that (e.g. https://github.com/evanw/esbuild/issues/1610) - var initDepMarkers = _ref2 => { - var { - deps - } = _ref2; + var check = job => checkRecursiveUpdates(seen, job); - if (deps.length) { - for (var i = 0; i < deps.length; i++) { - deps[i].w |= trackOpBit; // set was tracked - } - } - }; + try { + for (flushIndex = 0; flushIndex < queue.length; flushIndex++) { + var job = queue[flushIndex]; - var finalizeDepMarkers = effect => { - var { - deps - } = effect; + if (job && job.active !== false) { + if ("development" !== 'production' && check(job)) { + continue; + } // console.log(`running:`, job.id) - if (deps.length) { - var ptr = 0; - for (var i = 0; i < deps.length; i++) { - var dep = deps[i]; + callWithErrorHandling(job, null, 14 + /* SCHEDULER */ + ); + } + } + } finally { + flushIndex = 0; + queue.length = 0; + flushPostFlushCbs(seen); + isFlushing = false; + currentFlushPromise = null; // some postFlushCb queued jobs! + // keep flushing until it drains. - if (wasTracked(dep) && !newTracked(dep)) { - dep.delete(effect); - } else { - deps[ptr++] = dep; - } // clear bits + if (queue.length || pendingPreFlushCbs.length || pendingPostFlushCbs.length) { + flushJobs(seen); + } + } + } + function checkRecursiveUpdates(seen, fn) { + if (!seen.has(fn)) { + seen.set(fn, 1); + } else { + var count = seen.get(fn); - dep.w &= ~trackOpBit; - dep.n &= ~trackOpBit; + if (count > RECURSION_LIMIT) { + var instance = fn.ownerInstance; + var componentName = instance && getComponentName(instance.type); + warn("Maximum recursive updates exceeded".concat(componentName ? " in component <".concat(componentName, ">") : "", ". ") + "This means you have a reactive effect that is mutating its own " + "dependencies and thus recursively triggering itself. Possible sources " + "include component template, render function, updated hook or " + "watcher source function."); + return true; + } else { + seen.set(fn, count + 1); + } } - - deps.length = ptr; } - }; - - var targetMap = new WeakMap(); // The number of effects currently being tracked recursively. + /* eslint-disable no-restricted-globals */ - var effectTrackDepth = 0; - var trackOpBit = 1; - /** - * The bitwise track markers support at most 30 levels of recursion. - * This value is chosen to enable modern JS engines to use a SMI on all platforms. - * When recursion depth is greater, fall back to using a full cleanup. - */ - var maxMarkerBits = 30; - var activeEffect; - var ITERATE_KEY = Symbol('iterate'); - var MAP_KEY_ITERATE_KEY = Symbol('Map key iterate'); + var isHmrUpdating = false; + var hmrDirtyComponents = new Set(); // Expose the HMR runtime on the global object + // This makes it entirely tree-shakable without polluting the exports and makes + // it easier to be used in toolings like vue-loader + // Note: for a component to be eligible for HMR it also needs the __hmrId option + // to be set so that its instances can be registered / removed. - class ReactiveEffect { - constructor(fn) { - var scheduler = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null; - var scope = arguments.length > 2 ? arguments[2] : undefined; - this.fn = fn; - this.scheduler = scheduler; - this.active = true; - this.deps = []; - this.parent = undefined; - recordEffectScope(this, scope); + { + shared.getGlobalThis().__VUE_HMR_RUNTIME__ = { + createRecord: tryWrap(createRecord), + rerender: tryWrap(rerender), + reload: tryWrap(reload) + }; } + var map = new Map(); + + function registerHMR(instance) { + var id = instance.type.__hmrId; + var record = map.get(id); - run() { - if (!this.active) { - return this.fn(); + if (!record) { + createRecord(id, instance.type); + record = map.get(id); } - var parent = activeEffect; - var lastShouldTrack = shouldTrack; + record.instances.add(instance); + } - while (parent) { - if (parent === this) { - return; - } + function unregisterHMR(instance) { + map.get(instance.type.__hmrId).instances.delete(instance); + } - parent = parent.parent; + function createRecord(id, initialDef) { + if (map.has(id)) { + return false; } - try { - this.parent = activeEffect; - activeEffect = this; - shouldTrack = true; - trackOpBit = 1 << ++effectTrackDepth; + map.set(id, { + initialDef: normalizeClassComponent(initialDef), + instances: new Set() + }); + return true; + } - if (effectTrackDepth <= maxMarkerBits) { - initDepMarkers(this); - } else { - cleanupEffect(this); - } + function normalizeClassComponent(component) { + return isClassComponent(component) ? component.__vccOpts : component; + } - return this.fn(); - } finally { - if (effectTrackDepth <= maxMarkerBits) { - finalizeDepMarkers(this); - } + function rerender(id, newRender) { + var record = map.get(id); - trackOpBit = 1 << --effectTrackDepth; - activeEffect = this.parent; - shouldTrack = lastShouldTrack; - this.parent = undefined; - } - } + if (!record) { + return; + } // update initial record (for not-yet-rendered component) - stop() { - if (this.active) { - cleanupEffect(this); - if (this.onStop) { - this.onStop(); + record.initialDef.render = newRender; + [...record.instances].forEach(instance => { + if (newRender) { + instance.render = newRender; + normalizeClassComponent(instance.type).render = newRender; } - this.active = false; - } - } + instance.renderCache = []; // this flag forces child components with slot content to update - } + isHmrUpdating = true; + instance.update(); + isHmrUpdating = false; + }); + } - function cleanupEffect(effect) { - var { - deps - } = effect; + function reload(id, newComp) { + var record = map.get(id); + if (!record) return; + newComp = normalizeClassComponent(newComp); // update initial def (for not-yet-rendered components) - if (deps.length) { - for (var i = 0; i < deps.length; i++) { - deps[i].delete(effect); - } + updateComponentDef(record.initialDef, newComp); // create a snapshot which avoids the set being mutated during updates - deps.length = 0; - } - } + var instances = [...record.instances]; - function effect(fn, options) { - if (fn.effect) { - fn = fn.effect.fn; - } + for (var instance of instances) { + var oldComp = normalizeClassComponent(instance.type); - var _effect = new ReactiveEffect(fn); + if (!hmrDirtyComponents.has(oldComp)) { + // 1. Update existing comp definition to match new one + if (oldComp !== record.initialDef) { + updateComponentDef(oldComp, newComp); + } // 2. mark definition dirty. This forces the renderer to replace the + // component on patch. - if (options) { - extend(_effect, options); - if (options.scope) recordEffectScope(_effect, options.scope); - } - if (!options || !options.lazy) { - _effect.run(); - } + hmrDirtyComponents.add(oldComp); + } // 3. invalidate options resolution cache - var runner = _effect.run.bind(_effect); - runner.effect = _effect; - return runner; - } + instance.appContext.optionsCache.delete(instance.type); // 4. actually update - function stop(runner) { - runner.effect.stop(); - } + if (instance.ceReload) { + // custom element + hmrDirtyComponents.add(oldComp); + instance.ceReload(newComp.styles); + hmrDirtyComponents.delete(oldComp); + } else if (instance.parent) { + // 4. Force the parent instance to re-render. This will cause all updated + // components to be unmounted and re-mounted. Queue the update so that we + // don't end up forcing the same parent to re-render multiple times. + queueJob(instance.parent.update); // instance is the inner component of an async custom element + // invoke to reset styles - var shouldTrack = true; - var trackStack = []; + if (instance.parent.type.__asyncLoader && instance.parent.ceReload) { + instance.parent.ceReload(newComp.styles); + } + } else if (instance.appContext.reload) { + // root instance mounted via createApp() has a reload method + instance.appContext.reload(); + } else if (typeof window !== 'undefined') { + // root instance inside tree created via raw render(). Force reload. + window.location.reload(); + } else { + console.warn('[HMR] Root or manually mounted instance modified. Full reload required.'); + } + } // 5. make sure to cleanup dirty hmr components after update - function pauseTracking() { - trackStack.push(shouldTrack); - shouldTrack = false; - } - function resetTracking() { - var last = trackStack.pop(); - shouldTrack = last === undefined ? true : last; - } + queuePostFlushCb(() => { + for (var _instance of instances) { + hmrDirtyComponents.delete(normalizeClassComponent(_instance.type)); + } + }); + } - function track(target, type, key) { - if (shouldTrack && activeEffect) { - var depsMap = targetMap.get(target); + function updateComponentDef(oldComp, newComp) { + shared.extend(oldComp, newComp); - if (!depsMap) { - targetMap.set(target, depsMap = new Map()); + for (var key in oldComp) { + if (key !== '__file' && !(key in newComp)) { + delete oldComp[key]; + } } + } + + function tryWrap(fn) { + return (id, arg) => { + try { + return fn(id, arg); + } catch (e) { + console.error(e); + console.warn("[HMR] Something went wrong during Vue component hot-reload. " + "Full reload required."); + } + }; + } - var dep = depsMap.get(key); + var devtools; + var buffer = []; + var devtoolsNotInstalled = false; - if (!dep) { - depsMap.set(key, dep = createDep()); + function emit(event) { + for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) { + args[_key2 - 1] = arguments[_key2]; } - var eventInfo = { - effect: activeEffect, - target, - type, - key - }; - trackEffects(dep, eventInfo); + if (devtools) { + devtools.emit(event, ...args); + } else if (!devtoolsNotInstalled) { + buffer.push({ + event, + args + }); + } } - } - function trackEffects(dep, debuggerEventExtraInfo) { - var shouldTrack = false; + function setDevtoolsHook(hook, target) { + var _a, _b; - if (effectTrackDepth <= maxMarkerBits) { - if (!newTracked(dep)) { - dep.n |= trackOpBit; // set newly tracked + devtools = hook; - shouldTrack = !wasTracked(dep); + if (devtools) { + devtools.enabled = true; + buffer.forEach(_ref3 => { + var { + event, + args + } = _ref3; + return devtools.emit(event, ...args); + }); + buffer = []; + } else if ( // handle late devtools injection - only do this if we are in an actual + // browser environment to avoid the timer handle stalling test runner exit + // (#4815) + // eslint-disable-next-line no-restricted-globals + typeof window !== 'undefined' && // some envs mock window but not fully + window.HTMLElement && // also exclude jsdom + !((_b = (_a = window.navigator) === null || _a === void 0 ? void 0 : _a.userAgent) === null || _b === void 0 ? void 0 : _b.includes('jsdom'))) { + var replay = target.__VUE_DEVTOOLS_HOOK_REPLAY__ = target.__VUE_DEVTOOLS_HOOK_REPLAY__ || []; + replay.push(newHook => { + setDevtoolsHook(newHook, target); + }); // clear buffer after 3s - the user probably doesn't have devtools installed + // at all, and keeping the buffer will cause memory leaks (#4738) + + setTimeout(() => { + if (!devtools) { + target.__VUE_DEVTOOLS_HOOK_REPLAY__ = null; + devtoolsNotInstalled = true; + buffer = []; + } + }, 3000); + } else { + // non-browser env, assume not installed + devtoolsNotInstalled = true; + buffer = []; } - } else { - // Full cleanup mode. - shouldTrack = !dep.has(activeEffect); } - if (shouldTrack) { - dep.add(activeEffect); - activeEffect.deps.push(dep); + function devtoolsInitApp(app, version) { + emit("app:init" + /* APP_INIT */ + , app, version, { + Fragment, + Text, + Comment, + Static + }); + } - if (activeEffect.onTrack) { - activeEffect.onTrack(Object.assign({ - effect: activeEffect - }, debuggerEventExtraInfo)); - } + function devtoolsUnmountApp(app) { + emit("app:unmount" + /* APP_UNMOUNT */ + , app); } - } - function trigger(target, type, key, newValue, oldValue, oldTarget) { - var depsMap = targetMap.get(target); + var devtoolsComponentAdded = /*#__PURE__*/createDevtoolsComponentHook("component:added" + /* COMPONENT_ADDED */ + ); + var devtoolsComponentUpdated = /*#__PURE__*/createDevtoolsComponentHook("component:updated" + /* COMPONENT_UPDATED */ + ); + var devtoolsComponentRemoved = /*#__PURE__*/createDevtoolsComponentHook("component:removed" + /* COMPONENT_REMOVED */ + ); - if (!depsMap) { - // never been tracked - return; + function createDevtoolsComponentHook(hook) { + return component => { + emit(hook, component.appContext.app, component.uid, component.parent ? component.parent.uid : undefined, component); + }; } - var deps = []; + var devtoolsPerfStart = /*#__PURE__*/createDevtoolsPerformanceHook("perf:start" + /* PERFORMANCE_START */ + ); + var devtoolsPerfEnd = /*#__PURE__*/createDevtoolsPerformanceHook("perf:end" + /* PERFORMANCE_END */ + ); - if (type === "clear" - /* CLEAR */ - ) { - // collection being cleared - // trigger all effects for target - deps = [...depsMap.values()]; - } else if (key === 'length' && isArray(target)) { - depsMap.forEach((dep, key) => { - if (key === 'length' || key >= newValue) { - deps.push(dep); - } - }); - } else { - // schedule runs for SET | ADD | DELETE - if (key !== void 0) { - deps.push(depsMap.get(key)); - } // also run for iteration key on ADD | DELETE | Map.SET + function createDevtoolsPerformanceHook(hook) { + return (component, type, time) => { + emit(hook, component.appContext.app, component.uid, component, type, time); + }; + } + function devtoolsComponentEmit(component, event, params) { + emit("component:emit" + /* COMPONENT_EMIT */ + , component.appContext.app, component, event, params); + } - switch (type) { - case "add" - /* ADD */ - : - if (!isArray(target)) { - deps.push(depsMap.get(ITERATE_KEY)); + function emit$1(instance, event) { + var props = instance.vnode.props || shared.EMPTY_OBJ; - if (isMap(target)) { - deps.push(depsMap.get(MAP_KEY_ITERATE_KEY)); - } - } else if (isIntegerKey(key)) { - // new index added to array -> length changes - deps.push(depsMap.get('length')); - } + for (var _len3 = arguments.length, rawArgs = new Array(_len3 > 2 ? _len3 - 2 : 0), _key3 = 2; _key3 < _len3; _key3++) { + rawArgs[_key3 - 2] = arguments[_key3]; + } - break; + { + var { + emitsOptions, + propsOptions: [propsOptions] + } = instance; + + if (emitsOptions) { + if (!(event in emitsOptions) && !false) { + if (!propsOptions || !(shared.toHandlerKey(event) in propsOptions)) { + warn("Component emitted event \"".concat(event, "\" but it is neither declared in ") + "the emits option nor as an \"".concat(shared.toHandlerKey(event), "\" prop.")); + } + } else { + var validator = emitsOptions[event]; - case "delete" - /* DELETE */ - : - if (!isArray(target)) { - deps.push(depsMap.get(ITERATE_KEY)); + if (shared.isFunction(validator)) { + var isValid = validator(...rawArgs); - if (isMap(target)) { - deps.push(depsMap.get(MAP_KEY_ITERATE_KEY)); + if (!isValid) { + warn("Invalid event arguments: event validation failed for event \"".concat(event, "\".")); + } } } + } + } + var args = rawArgs; + var isModelListener = event.startsWith('update:'); // for v-model update:xxx events, apply modifiers on args - break; + var modelArg = isModelListener && event.slice(7); - case "set" - /* SET */ - : - if (isMap(target)) { - deps.push(depsMap.get(ITERATE_KEY)); - } + if (modelArg && modelArg in props) { + var modifiersKey = "".concat(modelArg === 'modelValue' ? 'model' : modelArg, "Modifiers"); + var { + number, + trim + } = props[modifiersKey] || shared.EMPTY_OBJ; - break; + if (trim) { + args = rawArgs.map(a => a.trim()); + } else if (number) { + args = rawArgs.map(shared.toNumber); + } } - } - var eventInfo = { - target, - type, - key, - newValue, - oldValue, - oldTarget - }; + { + devtoolsComponentEmit(instance, event, args); + } + { + var lowerCaseEvent = event.toLowerCase(); - if (deps.length === 1) { - if (deps[0]) { - { - triggerEffects(deps[0], eventInfo); + if (lowerCaseEvent !== event && props[shared.toHandlerKey(lowerCaseEvent)]) { + warn("Event \"".concat(lowerCaseEvent, "\" is emitted in component ") + "".concat(formatComponentName(instance, instance.type), " but the handler is registered for \"").concat(event, "\". ") + "Note that HTML attributes are case-insensitive and you cannot use " + "v-on to listen to camelCase events when using in-DOM templates. " + "You should probably use \"".concat(shared.hyphenate(event), "\" instead of \"").concat(event, "\".")); } } - } else { - var effects = []; + var handlerName; + var handler = props[handlerName = shared.toHandlerKey(event)] || // also try camelCase event handler (#2249) + props[handlerName = shared.toHandlerKey(shared.camelize(event))]; // for v-model update:xxx events, also trigger kebab-case equivalent + // for props passed via kebab-case - for (var dep of deps) { - if (dep) { - effects.push(...dep); - } + if (!handler && isModelListener) { + handler = props[handlerName = shared.toHandlerKey(shared.hyphenate(event))]; } - { - triggerEffects(createDep(effects), eventInfo); + if (handler) { + callWithAsyncErrorHandling(handler, instance, 6 + /* COMPONENT_EVENT_HANDLER */ + , args); } - } - } - function triggerEffects(dep, debuggerEventExtraInfo) { - // spread into array for stabilization - for (var _effect2 of isArray(dep) ? dep : [...dep]) { - if (_effect2 !== activeEffect || _effect2.allowRecurse) { - if (_effect2.onTrigger) { - _effect2.onTrigger(extend({ - effect: _effect2 - }, debuggerEventExtraInfo)); - } + var onceHandler = props[handlerName + "Once"]; - if (_effect2.scheduler) { - _effect2.scheduler(); - } else { - _effect2.run(); + if (onceHandler) { + if (!instance.emitted) { + instance.emitted = {}; + } else if (instance.emitted[handlerName]) { + return; } + + instance.emitted[handlerName] = true; + callWithAsyncErrorHandling(onceHandler, instance, 6 + /* COMPONENT_EVENT_HANDLER */ + , args); } } - } - var isNonTrackableKeys = /*#__PURE__*/makeMap("__proto__,__v_isRef,__isVue"); - var builtInSymbols = new Set(Object.getOwnPropertyNames(Symbol).map(key => Symbol[key]).filter(isSymbol)); - var get = /*#__PURE__*/createGetter(); - var shallowGet = /*#__PURE__*/createGetter(false, true); - var readonlyGet = /*#__PURE__*/createGetter(true); - var shallowReadonlyGet = /*#__PURE__*/createGetter(true, true); - var arrayInstrumentations = /*#__PURE__*/createArrayInstrumentations(); + function normalizeEmitsOptions(comp, appContext) { + var asMixin = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; + var cache = appContext.emitsCache; + var cached = cache.get(comp); - function createArrayInstrumentations() { - var instrumentations = {}; - ['includes', 'indexOf', 'lastIndexOf'].forEach(key => { - instrumentations[key] = function () { - var arr = toRaw(this); + if (cached !== undefined) { + return cached; + } - for (var 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) + var raw = comp.emits; + var normalized = {}; // apply mixin/extends props + var hasExtends = false; - for (var _len2 = arguments.length, args = new Array(_len2), _key3 = 0; _key3 < _len2; _key3++) { - args[_key3] = arguments[_key3]; - } + if (!shared.isFunction(comp)) { + var extendEmits = raw => { + var normalizedFromExtend = normalizeEmitsOptions(raw, appContext, true); - var res = arr[key](...args); + if (normalizedFromExtend) { + hasExtends = true; + shared.extend(normalized, normalizedFromExtend); + } + }; - if (res === -1 || res === false) { - // if that didn't work, run it again using raw values. - return arr[key](...args.map(toRaw)); - } else { - return res; + if (!asMixin && appContext.mixins.length) { + appContext.mixins.forEach(extendEmits); } - }; - }); - ['push', 'pop', 'shift', 'unshift', 'splice'].forEach(key => { - instrumentations[key] = function () { - pauseTracking(); - for (var _len3 = arguments.length, args = new Array(_len3), _key4 = 0; _key4 < _len3; _key4++) { - args[_key4] = arguments[_key4]; + if (comp.extends) { + extendEmits(comp.extends); } - var res = toRaw(this)[key].apply(this, args); - resetTracking(); - return res; - }; - }); - return instrumentations; - } - - function createGetter() { - var isReadonly = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; - var shallow = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 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_isShallow" - /* IS_SHALLOW */ - ) { - return shallow; - } else if (key === "__v_raw" - /* RAW */ - && receiver === (isReadonly ? shallow ? shallowReadonlyMap : readonlyMap : shallow ? shallowReactiveMap : reactiveMap).get(target)) { - return target; + if (comp.mixins) { + comp.mixins.forEach(extendEmits); + } } - var targetIsArray = isArray(target); - - if (!isReadonly && targetIsArray && hasOwn(arrayInstrumentations, key)) { - return Reflect.get(arrayInstrumentations, key, receiver); + if (!raw && !hasExtends) { + cache.set(comp, null); + return null; } - var res = Reflect.get(target, key, receiver); - - if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) { - return res; + if (shared.isArray(raw)) { + raw.forEach(key => normalized[key] = null); + } else { + shared.extend(normalized, raw); } - if (!isReadonly) { - track(target, "get" - /* GET */ - , key); - } + cache.set(comp, normalized); + return normalized; + } // Check if an incoming prop key is a declared emit event listener. + // e.g. With `emits: { click: null }`, props named `onClick` and `onclick` are + // both considered matched listeners. - if (shallow) { - return res; - } - if (isRef(res)) { - // ref unwrapping - does not apply for Array + integer key. - var shouldUnwrap = !targetIsArray || !isIntegerKey(key); - return shouldUnwrap ? res.value : res; + function isEmitListener(options, key) { + if (!options || !shared.isOn(key)) { + return false; } - 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); - } + key = key.slice(2).replace(/Once$/, ''); + return shared.hasOwn(options, key[0].toLowerCase() + key.slice(1)) || shared.hasOwn(options, shared.hyphenate(key)) || shared.hasOwn(options, key); + } + /** + * mark the current rendering instance for asset resolution (e.g. + * resolveComponent, resolveDirective) during render + */ - return res; - }; - } - var set = /*#__PURE__*/createSetter(); - var shallowSet = /*#__PURE__*/createSetter(true); - - function createSetter() { - var shallow = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; - return function set(target, key, value, receiver) { - var oldValue = target[key]; - - if (isReadonly(oldValue) && isRef(oldValue) && !isRef(value)) { - return false; - } - - if (!shallow && !isReadonly(value)) { - if (!isShallow(value)) { - value = toRaw(value); - oldValue = toRaw(oldValue); - } - - if (!isArray(target) && isRef(oldValue) && !isRef(value)) { - oldValue.value = value; - return true; - } - } - - var hadKey = isArray(target) && isIntegerKey(key) ? Number(key) < target.length : hasOwn(target, key); - var result = Reflect.set(target, key, value, receiver); // don't trigger if target is something up in the prototype chain of original - - if (target === toRaw(receiver)) { - if (!hadKey) { - trigger(target, "add" - /* ADD */ - , key, value); - } else if (hasChanged(value, oldValue)) { - trigger(target, "set" - /* SET */ - , key, value, oldValue); - } - } + var currentRenderingInstance = null; + var currentScopeId = null; + /** + * Note: rendering calls maybe nested. The function returns the parent rendering + * instance if present, which should be restored after the render is done: + * + * ```js + * const prev = setCurrentRenderingInstance(i) + * // ...render + * setCurrentRenderingInstance(prev) + * ``` + */ - return result; - }; - } + function setCurrentRenderingInstance(instance) { + var prev = currentRenderingInstance; + currentRenderingInstance = instance; + currentScopeId = instance && instance.type.__scopeId || null; + return prev; + } + /** + * Set scope id when creating hoisted vnodes. + * @private compiler helper + */ - function deleteProperty(target, key) { - var hadKey = hasOwn(target, key); - var oldValue = target[key]; - var result = Reflect.deleteProperty(target, key); - if (result && hadKey) { - trigger(target, "delete" - /* DELETE */ - , key, undefined, oldValue); + function pushScopeId(id) { + currentScopeId = id; } + /** + * Technically we no longer need this after 3.0.8 but we need to keep the same + * API for backwards compat w/ code generated by compilers. + * @private + */ - return result; - } - - function has(target, key) { - var result = Reflect.has(target, key); - if (!isSymbol(key) || !builtInSymbols.has(key)) { - track(target, "has" - /* HAS */ - , key); + function popScopeId() { + currentScopeId = null; } + /** + * Only for backwards compat + * @private + */ - return result; - } - function ownKeys(target) { - track(target, "iterate" - /* ITERATE */ - , isArray(target) ? 'length' : ITERATE_KEY); - return Reflect.ownKeys(target); - } + var withScopeId = _id => withCtx; + /** + * Wrap a slot function to memoize current rendering instance + * @private compiler helper + */ - var mutableHandlers = { - get, - set, - deleteProperty, - has, - ownKeys - }; - var readonlyHandlers = { - get: readonlyGet, - set(target, key) { - { - console.warn("Set operation on key \"".concat(String(key), "\" failed: target is readonly."), target); - } - return true; - }, + function withCtx(fn) { + var ctx = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : currentRenderingInstance; + var isNonScopedSlot // false only + = arguments.length > 2 ? arguments[2] : undefined; + if (!ctx) return fn; // already normalized - deleteProperty(target, key) { - { - console.warn("Delete operation on key \"".concat(String(key), "\" failed: target is readonly."), target); + if (fn._n) { + return fn; } - return true; - } - }; - var shallowReactiveHandlers = /*#__PURE__*/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. - - var shallowReadonlyHandlers = /*#__PURE__*/extend({}, readonlyHandlers, { - get: shallowReadonlyGet - }); - - var toShallow = value => value; - - var getProto = v => Reflect.getPrototypeOf(v); - - function get$1(target, key) { - var isReadonly = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; - var isShallow = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false; - // #1772: readonly(reactive(Map)) should return readonly + reactive version - // of the value - target = target["__v_raw" - /* RAW */ - ]; - var rawTarget = toRaw(target); - var rawKey = toRaw(key); - - if (key !== rawKey) { - !isReadonly && track(rawTarget, "get" - /* GET */ - , key); - } - - !isReadonly && track(rawTarget, "get" - /* GET */ - , rawKey); - var { - has - } = getProto(rawTarget); - var wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive; - - if (has.call(rawTarget, key)) { - return wrap(target.get(key)); - } else if (has.call(rawTarget, rawKey)) { - return wrap(target.get(rawKey)); - } else if (target !== rawTarget) { - // #3602 readonly(reactive(Map)) - // ensure that the nested reactive `Map` can do tracking for itself - target.get(key); - } - } - - function has$1(key) { - var isReadonly = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; - var target = this["__v_raw" - /* RAW */ - ]; - var rawTarget = toRaw(target); - var 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) { - var isReadonly = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 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); - var target = toRaw(this); - var proto = getProto(target); - var hadKey = proto.has.call(target, value); - - if (!hadKey) { - target.add(value); - trigger(target, "add" - /* ADD */ - , value, value); - } - - return this; - } - - function set$1(key, value) { - value = toRaw(value); - var target = toRaw(this); - var { - has, - get - } = getProto(target); - var hadKey = has.call(target, key); - - if (!hadKey) { - key = toRaw(key); - hadKey = has.call(target, key); - } else { - checkIdentityKeys(target, has, key); - } - - var oldValue = get.call(target, key); - target.set(key, value); - - if (!hadKey) { - trigger(target, "add" - /* ADD */ - , key, value); - } else if (hasChanged(value, oldValue)) { - trigger(target, "set" - /* SET */ - , key, value, oldValue); - } - - return this; - } - - function deleteEntry(key) { - var target = toRaw(this); - var { - has, - get - } = getProto(target); - var hadKey = has.call(target, key); - - if (!hadKey) { - key = toRaw(key); - hadKey = has.call(target, key); - } else { - checkIdentityKeys(target, has, key); - } - - var oldValue = get ? get.call(target, key) : undefined; // forward the operation before queueing reactions - - var result = target.delete(key); - - if (hadKey) { - trigger(target, "delete" - /* DELETE */ - , key, undefined, oldValue); - } - - return result; - } - - function clear() { - var target = toRaw(this); - var hadItems = target.size !== 0; - var oldTarget = isMap(target) ? new Map(target) : new Set(target); // forward the operation before queueing reactions - - var result = target.clear(); - - if (hadItems) { - trigger(target, "clear" - /* CLEAR */ - , undefined, undefined, oldTarget); - } - - return result; - } - - function createForEach(isReadonly, isShallow) { - return function forEach(callback, thisArg) { - var observed = this; - var target = observed["__v_raw" - /* RAW */ - ]; - var rawTarget = toRaw(target); - var wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive; - !isReadonly && track(rawTarget, "iterate" - /* ITERATE */ - , ITERATE_KEY); - return target.forEach((value, key) => { - // important: make sure the callback is - // 1. invoked with the reactive map as `this` and 3rd arg - // 2. the value received should be a corresponding reactive/readonly. - return callback.call(thisArg, wrap(value), wrap(key), observed); - }); - }; - } - - function createIterableMethod(method, isReadonly, isShallow) { - return function () { - var target = this["__v_raw" - /* RAW */ - ]; - var rawTarget = toRaw(target); - var targetIsMap = isMap(rawTarget); - var isPair = method === 'entries' || method === Symbol.iterator && targetIsMap; - var isKeyOnly = method === 'keys' && targetIsMap; - var innerIterator = target[method](...arguments); - var wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive; - !isReadonly && track(rawTarget, "iterate" - /* ITERATE */ - , isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY); // return a wrapped iterator which returns observed versions of the - // values emitted from the real iterator + var renderFnWithContext = function () { + // If a user calls a compiled slot inside a template expression (#1745), it + // can mess up block tracking, so by default we disable block tracking and + // force bail out when invoking a compiled slot (indicated by the ._d flag). + // This isn't necessary if rendering a compiled ``, so we flip the + // ._d flag off when invoking the wrapped fn inside `renderSlot`. + if (renderFnWithContext._d) { + setBlockTracking(-1); + } - return { - // iterator protocol - next() { - var { - value, - done - } = innerIterator.next(); - return done ? { - value, - done - } : { - value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value), - done - }; - }, + var prevInstance = setCurrentRenderingInstance(ctx); + var res = fn(...arguments); + setCurrentRenderingInstance(prevInstance); - // iterable protocol - [Symbol.iterator]() { - return this; + if (renderFnWithContext._d) { + setBlockTracking(1); } - }; - }; - } + { + devtoolsComponentUpdated(ctx); + } + return res; + }; // mark normalized to avoid duplicated wrapping - function createReadonlyMethod(type) { - return function () { - { - var key = (arguments.length <= 0 ? undefined : arguments[0]) ? "on key \"".concat(arguments.length <= 0 ? undefined : arguments[0], "\" ") : ""; - console.warn("".concat(capitalize(type), " operation ").concat(key, "failed: target is readonly."), toRaw(this)); - } - return type === "delete" - /* DELETE */ - ? false : this; - }; - } - function createInstrumentations() { - var mutableInstrumentations = { - get(key) { - return get$1(this, key); - }, + renderFnWithContext._n = true; // mark this as compiled by default + // this is used in vnode.ts -> normalizeChildren() to set the slot + // rendering flag. - get size() { - return size(this); - }, + renderFnWithContext._c = true; // disable block tracking by default - has: has$1, - add, - set: set$1, - delete: deleteEntry, - clear, - forEach: createForEach(false, false) - }; - var shallowInstrumentations = { - get(key) { - return get$1(this, key, false, true); - }, + renderFnWithContext._d = true; + return renderFnWithContext; + } + /** + * dev only flag to track whether $attrs was used during render. + * If $attrs was used during render then the warning for failed attrs + * fallthrough can be suppressed. + */ - get size() { - return size(this); - }, - has: has$1, - add, - set: set$1, - delete: deleteEntry, - clear, - forEach: createForEach(false, true) - }; - var readonlyInstrumentations = { - get(key) { - return get$1(this, key, true); - }, + var accessedAttrs = false; - get size() { - return size(this, true); - }, + function markAttrsAccessed() { + accessedAttrs = true; + } - has(key) { - return has$1.call(this, key, true); - }, + function renderComponentRoot(instance) { + var { + type: Component, + vnode, + proxy, + withProxy, + props, + propsOptions: [propsOptions], + slots, + attrs, + emit, + render, + renderCache, + data, + setupState, + ctx, + inheritAttrs + } = instance; + var result; + var fallthroughAttrs; + var prev = setCurrentRenderingInstance(instance); + { + accessedAttrs = false; + } - add: createReadonlyMethod("add" - /* ADD */ - ), - set: createReadonlyMethod("set" - /* SET */ - ), - delete: createReadonlyMethod("delete" - /* DELETE */ - ), - clear: createReadonlyMethod("clear" - /* CLEAR */ - ), - forEach: createForEach(true, false) - }; - var shallowReadonlyInstrumentations = { - get(key) { - return get$1(this, key, true, true); - }, + try { + if (vnode.shapeFlag & 4 + /* STATEFUL_COMPONENT */ + ) { + // withProxy is a proxy with a different `has` trap only for + // runtime-compiled render functions using `with` block. + var proxyToUse = withProxy || proxy; + result = normalizeVNode(render.call(proxyToUse, proxyToUse, renderCache, props, setupState, data, ctx)); + fallthroughAttrs = attrs; + } else { + // functional + var _render = Component; // in dev, mark attrs accessed if optional props (attrs === props) - get size() { - return size(this, true); - }, + if ("development" !== 'production' && attrs === props) { + markAttrsAccessed(); + } - has(key) { - return has$1.call(this, key, true); - }, + result = normalizeVNode(_render.length > 1 ? _render(props, "development" !== 'production' ? { + get attrs() { + markAttrsAccessed(); + return attrs; + }, - add: createReadonlyMethod("add" - /* ADD */ - ), - set: createReadonlyMethod("set" - /* SET */ - ), - delete: createReadonlyMethod("delete" - /* DELETE */ - ), - clear: createReadonlyMethod("clear" - /* CLEAR */ - ), - forEach: createForEach(true, true) - }; - var iteratorMethods = ['keys', 'values', 'entries', Symbol.iterator]; - iteratorMethods.forEach(method => { - mutableInstrumentations[method] = createIterableMethod(method, false, false); - readonlyInstrumentations[method] = createIterableMethod(method, true, false); - shallowInstrumentations[method] = createIterableMethod(method, false, true); - shallowReadonlyInstrumentations[method] = createIterableMethod(method, true, true); - }); - return [mutableInstrumentations, readonlyInstrumentations, shallowInstrumentations, shallowReadonlyInstrumentations]; - } + slots, + emit + } : { + attrs, + slots, + emit + }) : _render(props, null + /* we know it doesn't need it */ + )); + fallthroughAttrs = Component.props ? attrs : getFunctionalFallthrough(attrs); + } + } catch (err) { + blockStack.length = 0; + handleError(err, instance, 1 + /* RENDER_FUNCTION */ + ); + result = createVNode(Comment); + } // 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 - var [mutableInstrumentations, readonlyInstrumentations, shallowInstrumentations, shallowReadonlyInstrumentations] = /* #__PURE__*/createInstrumentations(); - function createInstrumentationGetter(isReadonly, shallow) { - var instrumentations = shallow ? isReadonly ? shallowReadonlyInstrumentations : shallowInstrumentations : isReadonly ? readonlyInstrumentations : mutableInstrumentations; - return (target, key, receiver) => { - if (key === "__v_isReactive" - /* IS_REACTIVE */ - ) { - return !isReadonly; - } else if (key === "__v_isReadonly" - /* IS_READONLY */ - ) { - return isReadonly; - } else if (key === "__v_raw" - /* RAW */ + var root = result; + var setRoot = undefined; + + if (result.patchFlag > 0 && result.patchFlag & 2048 + /* DEV_ROOT_FRAGMENT */ ) { - return target; + [root, setRoot] = getChildRoot(result); } - return Reflect.get(hasOwn(instrumentations, key) && key in target ? instrumentations : target, key, receiver); - }; - } - - var mutableCollectionHandlers = { - get: /*#__PURE__*/createInstrumentationGetter(false, false) - }; - var shallowCollectionHandlers = { - get: /*#__PURE__*/createInstrumentationGetter(false, true) - }; - var readonlyCollectionHandlers = { - get: /*#__PURE__*/createInstrumentationGetter(true, false) - }; - var shallowReadonlyCollectionHandlers = { - get: /*#__PURE__*/createInstrumentationGetter(true, true) - }; - - function checkIdentityKeys(target, has, key) { - var rawKey = toRaw(key); - - if (rawKey !== key && has.call(target, rawKey)) { - var type = toRawType(target); - console.warn("Reactive ".concat(type, " contains both the raw and reactive ") + "versions of the same object".concat(type === "Map" ? " as keys" : "", ", ") + "which can lead to inconsistencies. " + "Avoid differentiating between the raw and reactive versions " + "of an object and only use the reactive version if possible."); - } - } - - var reactiveMap = new WeakMap(); - var shallowReactiveMap = new WeakMap(); - var readonlyMap = new WeakMap(); - var shallowReadonlyMap = new WeakMap(); - - function targetTypeMap(rawType) { - switch (rawType) { - case 'Object': - case 'Array': - return 1 - /* COMMON */ - ; - - case 'Map': - case 'Set': - case 'WeakMap': - case 'WeakSet': - return 2 - /* COLLECTION */ - ; - - default: - return 0 - /* INVALID */ - ; - } - } + if (fallthroughAttrs && inheritAttrs !== false) { + var keys = Object.keys(fallthroughAttrs); + var { + shapeFlag + } = root; - function getTargetType(value) { - return value["__v_skip" - /* SKIP */ - ] || !Object.isExtensible(value) ? 0 - /* INVALID */ - : targetTypeMap(toRawType(value)); - } + if (keys.length) { + if (shapeFlag & (1 + /* ELEMENT */ + | 6 + /* COMPONENT */ + )) { + if (propsOptions && keys.some(shared.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); + } - function reactive(target) { - // if trying to observe a readonly proxy, return the readonly version. - if (isReadonly(target)) { - return target; - } + root = cloneVNode(root, fallthroughAttrs); + } else if (!accessedAttrs && root.type !== Comment) { + var allAttrs = Object.keys(attrs); + var eventAttrs = []; + var extraAttrs = []; + + for (var i = 0, l = allAttrs.length; i < l; i++) { + var key = allAttrs[i]; + + if (shared.isOn(key)) { + // ignore v-model handlers when they fail to fallthrough + if (!shared.isModelListener(key)) { + // remove `on`, lowercase first letter to reflect event casing + // accurately + eventAttrs.push(key[2].toLowerCase() + key.slice(3)); + } + } else { + extraAttrs.push(key); + } + } - return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers, reactiveMap); - } - /** - * Return a shallowly-reactive copy of the original object, where only the root - * level properties are reactive. It also does not auto-unwrap refs (even at the - * root level). - */ + if (extraAttrs.length) { + warn("Extraneous non-props attributes (" + "".concat(extraAttrs.join(', '), ") ") + "were passed to component but could not be automatically inherited " + "because component renders fragment or text root nodes."); + } + if (eventAttrs.length) { + warn("Extraneous non-emits event listeners (" + "".concat(eventAttrs.join(', '), ") ") + "were passed to component but could not be automatically inherited " + "because component renders fragment or text root nodes. " + "If the listener is intended to be a component custom event listener only, " + "declare it using the \"emits\" option."); + } + } + } + } // inherit directives - function shallowReactive(target) { - return createReactiveObject(target, false, shallowReactiveHandlers, shallowCollectionHandlers, shallowReactiveMap); - } - /** - * Creates a readonly copy of the original object. Note the returned copy is not - * made reactive, but `readonly` can be called on an already reactive object. - */ + if (vnode.dirs) { + if (!isElementRoot(root)) { + warn("Runtime directive used on component with non-element root node. " + "The directives will not function as intended."); + } - function readonly(target) { - return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers, readonlyMap); - } - /** - * Returns a reactive-copy of the original object, where only the root level - * properties are readonly, and does NOT unwrap refs nor recursively convert - * returned properties. - * This is used for creating the props proxy object for stateful components. - */ + root.dirs = root.dirs ? root.dirs.concat(vnode.dirs) : vnode.dirs; + } // inherit transition data - function shallowReadonly(target) { - return createReactiveObject(target, true, shallowReadonlyHandlers, shallowReadonlyCollectionHandlers, shallowReadonlyMap); - } + if (vnode.transition) { + if (!isElementRoot(root)) { + warn("Component inside renders non-element root node " + "that cannot be animated."); + } - function createReactiveObject(target, isReadonly, baseHandlers, collectionHandlers, proxyMap) { - if (!isObject(target)) { - { - console.warn("value cannot be made reactive: ".concat(String(target))); + root.transition = vnode.transition; } - 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 - - - var existingProxy = proxyMap.get(target); - if (existingProxy) { - return existingProxy; - } // only a whitelist of value types can be observed. - - - var targetType = getTargetType(target); + if (setRoot) { + setRoot(root); + } else { + result = root; + } - if (targetType === 0 - /* INVALID */ - ) { - return target; + setCurrentRenderingInstance(prev); + return result; } + /** + * dev only + * In dev mode, template root level comments are rendered, which turns the + * template into a fragment root, but we need to locate the single element + * root for attrs and scope id processing. + */ - var 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 */ - ]); - } + var getChildRoot = vnode => { + var rawChildren = vnode.children; + var dynamicChildren = vnode.dynamicChildren; + var childRoot = filterSingleRoot(rawChildren); - return !!(value && value["__v_isReactive" - /* IS_REACTIVE */ - ]); - } - - function isReadonly(value) { - return !!(value && value["__v_isReadonly" - /* IS_READONLY */ - ]); - } - - function isShallow(value) { - return !!(value && value["__v_isShallow" - /* IS_SHALLOW */ - ]); - } - - function isProxy(value) { - return isReactive(value) || isReadonly(value); - } - - function toRaw(observed) { - var raw = observed && observed["__v_raw" - /* RAW */ - ]; - return raw ? toRaw(raw) : observed; - } - - function markRaw(value) { - def(value, "__v_skip" - /* SKIP */ - , true); - return value; - } - - var toReactive = value => isObject(value) ? reactive(value) : value; - - var toReadonly = value => isObject(value) ? readonly(value) : value; - - function trackRefValue(ref) { - if (shouldTrack && activeEffect) { - ref = toRaw(ref); - { - trackEffects(ref.dep || (ref.dep = createDep()), { - target: ref, - type: "get" - /* GET */ - , - key: 'value' - }); + if (!childRoot) { + return [vnode, undefined]; } - } - } - - function triggerRefValue(ref, newVal) { - ref = toRaw(ref); - if (ref.dep) { - { - triggerEffects(ref.dep, { - target: ref, - type: "set" - /* SET */ - , - key: 'value', - newValue: newVal - }); - } - } - } + var index = rawChildren.indexOf(childRoot); + var dynamicIndex = dynamicChildren ? dynamicChildren.indexOf(childRoot) : -1; - function isRef(r) { - return !!(r && r.__v_isRef === true); - } + var setRoot = updatedRoot => { + rawChildren[index] = updatedRoot; - function ref(value) { - return createRef(value, false); - } + if (dynamicChildren) { + if (dynamicIndex > -1) { + dynamicChildren[dynamicIndex] = updatedRoot; + } else if (updatedRoot.patchFlag > 0) { + vnode.dynamicChildren = [...dynamicChildren, updatedRoot]; + } + } + }; - function shallowRef(value) { - return createRef(value, true); - } + return [normalizeVNode(childRoot), setRoot]; + }; - function createRef(rawValue, shallow) { - if (isRef(rawValue)) { - return rawValue; - } + function filterSingleRoot(children) { + var singleRoot; - return new RefImpl(rawValue, shallow); - } + for (var i = 0; i < children.length; i++) { + var child = children[i]; - class RefImpl { - constructor(value, __v_isShallow) { - this.__v_isShallow = __v_isShallow; - this.dep = undefined; - this.__v_isRef = true; - this._rawValue = __v_isShallow ? value : toRaw(value); - this._value = __v_isShallow ? value : toReactive(value); - } + if (isVNode(child)) { + // ignore user comment + if (child.type !== Comment || child.children === 'v-if') { + if (singleRoot) { + // has more than 1 non-comment child, return now + return; + } else { + singleRoot = child; + } + } + } else { + return; + } + } - get value() { - trackRefValue(this); - return this._value; + return singleRoot; } - set value(newVal) { - newVal = this.__v_isShallow ? newVal : toRaw(newVal); + var getFunctionalFallthrough = attrs => { + var res; - if (hasChanged(newVal, this._rawValue)) { - this._rawValue = newVal; - this._value = this.__v_isShallow ? newVal : toReactive(newVal); - triggerRefValue(this, newVal); + for (var key in attrs) { + if (key === 'class' || key === 'style' || shared.isOn(key)) { + (res || (res = {}))[key] = attrs[key]; + } } - } - - } - function triggerRef(ref) { - triggerRefValue(ref, ref.value); - } - - function unref(ref) { - return isRef(ref) ? ref.value : ref; - } + return res; + }; - var shallowUnwrapHandlers = { - get: (target, key, receiver) => unref(Reflect.get(target, key, receiver)), - set: (target, key, value, receiver) => { - var oldValue = target[key]; + var filterModelListeners = (attrs, props) => { + var res = {}; - if (isRef(oldValue) && !isRef(value)) { - oldValue.value = value; - return true; - } else { - return Reflect.set(target, key, value, receiver); + for (var key in attrs) { + if (!shared.isModelListener(key) || !(key.slice(9) in props)) { + res[key] = attrs[key]; + } } - } - }; - - function proxyRefs(objectWithRefs) { - return isReactive(objectWithRefs) ? objectWithRefs : new Proxy(objectWithRefs, shallowUnwrapHandlers); - } - - class CustomRefImpl { - constructor(factory) { - this.dep = undefined; - this.__v_isRef = true; - var { - get, - set - } = factory(() => trackRefValue(this), () => triggerRefValue(this)); - this._get = get; - this._set = set; - } - get value() { - return this._get(); - } + return res; + }; - set value(newVal) { - this._set(newVal); - } + var isElementRoot = vnode => { + return vnode.shapeFlag & (6 + /* COMPONENT */ + | 1 + /* ELEMENT */ + ) || vnode.type === Comment // potential v-if branch switch + ; + }; - } + function shouldUpdateComponent(prevVNode, nextVNode, optimized) { + var { + props: prevProps, + children: prevChildren, + component + } = prevVNode; + var { + props: nextProps, + children: nextChildren, + patchFlag + } = nextVNode; + var emits = component.emitsOptions; // Parent component's render function was hot-updated. Since this may have + // caused the child component's slots content to have changed, we need to + // force the child to update as well. - function customRef(factory) { - return new CustomRefImpl(factory); - } + if ((prevChildren || nextChildren) && isHmrUpdating) { + return true; + } // force child update for runtime directive or transition on component vnode. - function toRefs(object) { - if (!isProxy(object)) { - console.warn("toRefs() expects a reactive object but received a plain one."); - } - var ret = isArray(object) ? new Array(object.length) : {}; + if (nextVNode.dirs || nextVNode.transition) { + return true; + } - for (var key in object) { - ret[key] = toRef(object, key); - } + 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; + } - return ret; - } + if (patchFlag & 16 + /* FULL_PROPS */ + ) { + if (!prevProps) { + return !!nextProps; + } // presence of this flag indicates props are always non-null - class ObjectRefImpl { - constructor(_object, _key, _defaultValue) { - this._object = _object; - this._key = _key; - this._defaultValue = _defaultValue; - this.__v_isRef = true; - } - get value() { - var val = this._object[this._key]; - return val === undefined ? this._defaultValue : val; - } + return hasPropsChanged(prevProps, nextProps, emits); + } else if (patchFlag & 8 + /* PROPS */ + ) { + var dynamicProps = nextVNode.dynamicProps; - set value(newVal) { - this._object[this._key] = newVal; - } + for (var i = 0; i < dynamicProps.length; i++) { + var 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; + } + } - function toRef(object, key, defaultValue) { - var val = object[key]; - return isRef(val) ? val : new ObjectRefImpl(object, key, defaultValue); - } + if (prevProps === nextProps) { + return false; + } - class ComputedRefImpl { - constructor(getter, _setter, isReadonly, isSSR) { - this._setter = _setter; - this.dep = undefined; - this.__v_isRef = true; - this._dirty = true; - this.effect = new ReactiveEffect(getter, () => { - if (!this._dirty) { - this._dirty = true; - triggerRefValue(this); + if (!prevProps) { + return !!nextProps; } - }); - this.effect.computed = this; - this.effect.active = this._cacheable = !isSSR; - this["__v_isReadonly" - /* IS_READONLY */ - ] = isReadonly; - } - get value() { - // the computed ref may get wrapped by other proxies e.g. readonly() #3376 - var self = toRaw(this); - trackRefValue(self); + if (!nextProps) { + return true; + } - if (self._dirty || !self._cacheable) { - self._dirty = false; - self._value = self.effect.run(); + return hasPropsChanged(prevProps, nextProps, emits); } - return self._value; + return false; } - set value(newValue) { - this._setter(newValue); - } + function hasPropsChanged(prevProps, nextProps, emitsOptions) { + var nextKeys = Object.keys(nextProps); - } + if (nextKeys.length !== Object.keys(prevProps).length) { + return true; + } - function computed(getterOrOptions, debugOptions) { - var isSSR = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; - var getter; - var setter; - var onlyGetter = isFunction(getterOrOptions); + for (var i = 0; i < nextKeys.length; i++) { + var key = nextKeys[i]; - if (onlyGetter) { - getter = getterOrOptions; + if (nextProps[key] !== prevProps[key] && !isEmitListener(emitsOptions, key)) { + return true; + } + } - setter = () => { - console.warn('Write operation failed: computed value is readonly'); - }; - } else { - getter = getterOrOptions.get; - setter = getterOrOptions.set; + return false; } - var cRef = new ComputedRefImpl(getter, setter, onlyGetter || !setter, isSSR); + function updateHOCHostEl(_ref4, el // HostNode + ) { + var { + vnode, + parent + } = _ref4; - if (debugOptions && !isSSR) { - cRef.effect.onTrack = debugOptions.onTrack; - cRef.effect.onTrigger = debugOptions.onTrigger; + while (parent && parent.subTree === vnode) { + (vnode = parent.vnode).el = el; + parent = parent.parent; + } } - return cRef; - } + var isSuspense = type => type.__isSuspense; // Suspense exposes a component-like API, and is treated like a component + // in the compiler, but internally it's a special built-in type that hooks + // directly into the renderer. - var stack = []; - function pushWarningContext(vnode) { - stack.push(vnode); - } + var SuspenseImpl = { + name: 'Suspense', + // In order to make Suspense tree-shakable, we need to avoid importing it + // directly in the renderer. The renderer checks for the __isSuspense flag + // on a vnode's type and calls the `process` method, passing in renderer + // internals. + __isSuspense: true, - function popWarningContext() { - stack.pop(); - } + process(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, // platform-specific impl passed from renderer + rendererInternals) { + if (n1 == null) { + mountSuspense(n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, rendererInternals); + } else { + patchSuspense(n1, n2, container, anchor, parentComponent, isSVG, slotScopeIds, optimized, rendererInternals); + } + }, - function warn$1(msg) { - // avoid props formatting or warn handler tracking deps that might be mutated - // during patch, leading to infinite recursion. - pauseTracking(); - var instance = stack.length ? stack[stack.length - 1].component : null; - var appWarnHandler = instance && instance.appContext.config.warnHandler; - var trace = getComponentTrace(); + hydrate: hydrateSuspense, + create: createSuspenseBoundary, + normalize: normalizeSuspenseChildren + }; // Force-casted public typing for h and TSX props inference - for (var _len4 = arguments.length, args = new Array(_len4 > 1 ? _len4 - 1 : 0), _key5 = 1; _key5 < _len4; _key5++) { - args[_key5 - 1] = arguments[_key5]; - } + var Suspense = SuspenseImpl; - if (appWarnHandler) { - callWithErrorHandling(appWarnHandler, instance, 11 - /* APP_WARN_HANDLER */ - , [msg + args.join(''), instance && instance.proxy, trace.map(_ref3 => { - var { - vnode - } = _ref3; - return "at <".concat(formatComponentName(instance, vnode.type), ">"); - }).join('\n'), trace]); - } else { - var warnArgs = ["[Vue warn]: ".concat(msg), ...args]; - /* istanbul ignore if */ + function triggerEvent(vnode, name) { + var eventListener = vnode.props && vnode.props[name]; - if (trace.length && // avoid spamming console during tests - !false) { - warnArgs.push("\n", ...formatTrace(trace)); + if (shared.isFunction(eventListener)) { + eventListener(); } - - console.warn(...warnArgs); } - resetTracking(); - } - - function getComponentTrace() { - var 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. - + function mountSuspense(vnode, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, rendererInternals) { + var { + p: patch, + o: { + createElement + } + } = rendererInternals; + var hiddenContainer = createElement('div'); + var suspense = vnode.suspense = createSuspenseBoundary(vnode, parentSuspense, parentComponent, container, hiddenContainer, anchor, isSVG, slotScopeIds, optimized, rendererInternals); // start mounting the content subtree in an off-dom container - var normalizedStack = []; + patch(null, suspense.pendingBranch = vnode.ssContent, hiddenContainer, null, parentComponent, suspense, isSVG, slotScopeIds); // now check if we have encountered any async deps - while (currentVNode) { - var last = normalizedStack[0]; + if (suspense.deps > 0) { + // has async + // invoke @fallback event + triggerEvent(vnode, 'onPending'); + triggerEvent(vnode, 'onFallback'); // mount the fallback tree - if (last && last.vnode === currentVNode) { - last.recurseCount++; + patch(null, vnode.ssFallback, container, anchor, parentComponent, null, // fallback tree will not have suspense context + isSVG, slotScopeIds); + setActiveBranch(suspense, vnode.ssFallback); } else { - normalizedStack.push({ - vnode: currentVNode, - recurseCount: 0 - }); + // Suspense has no async deps. Just resolve. + suspense.resolve(); } - - var parentInstance = currentVNode.component && currentVNode.component.parent; - currentVNode = parentInstance && parentInstance.vnode; } - return normalizedStack; - } - /* istanbul ignore next */ + function patchSuspense(n1, n2, container, anchor, parentComponent, isSVG, slotScopeIds, optimized, _ref5) { + var { + p: patch, + um: unmount, + o: { + createElement + } + } = _ref5; + var suspense = n2.suspense = n1.suspense; + suspense.vnode = n2; + n2.el = n1.el; + var newBranch = n2.ssContent; + var newFallback = n2.ssFallback; + var { + activeBranch, + pendingBranch, + isInFallback, + isHydrating + } = suspense; + if (pendingBranch) { + suspense.pendingBranch = newBranch; - function formatTrace(trace) { - var logs = []; - trace.forEach((entry, i) => { - logs.push(...(i === 0 ? [] : ["\n"]), ...formatTraceEntry(entry)); - }); - return logs; - } - - function formatTraceEntry(_ref4) { - var { - vnode, - recurseCount - } = _ref4; - var postfix = recurseCount > 0 ? "... (".concat(recurseCount, " recursive calls)") : ""; - var isRoot = vnode.component ? vnode.component.parent == null : false; - var open = " at <".concat(formatComponentName(vnode.component, vnode.type, isRoot)); - var close = ">" + postfix; - return vnode.props ? [open, ...formatProps(vnode.props), close] : [open + close]; - } - /* istanbul ignore next */ - - - function formatProps(props) { - var res = []; - var keys = Object.keys(props); - keys.slice(0, 3).forEach(key => { - res.push(...formatProp(key, props[key])); - }); + if (isSameVNodeType(newBranch, pendingBranch)) { + // same root type but content may have changed. + patch(pendingBranch, newBranch, suspense.hiddenContainer, null, parentComponent, suspense, isSVG, slotScopeIds, optimized); - if (keys.length > 3) { - res.push(" ..."); - } + if (suspense.deps <= 0) { + suspense.resolve(); + } else if (isInFallback) { + patch(activeBranch, newFallback, container, anchor, parentComponent, null, // fallback tree will not have suspense context + isSVG, slotScopeIds, optimized); + setActiveBranch(suspense, newFallback); + } + } else { + // toggled before pending tree is resolved + suspense.pendingId++; + + if (isHydrating) { + // if toggled before hydration is finished, the current DOM tree is + // no longer valid. set it as the active branch so it will be unmounted + // when resolved + suspense.isHydrating = false; + suspense.activeBranch = pendingBranch; + } else { + unmount(pendingBranch, parentComponent, suspense); + } // increment pending ID. this is used to invalidate async callbacks + // reset suspense state - return res; - } - /* istanbul ignore next */ + suspense.deps = 0; // discard effects from pending branch - function formatProp(key, value, raw) { - if (isString(value)) { - value = JSON.stringify(value); - return raw ? value : ["".concat(key, "=").concat(value)]; - } else if (typeof value === 'number' || typeof value === 'boolean' || value == null) { - return raw ? value : ["".concat(key, "=").concat(value)]; - } else if (isRef(value)) { - value = formatProp(key, toRaw(value.value), true); - return raw ? value : ["".concat(key, "=Ref<"), value, ">"]; - } else if (isFunction(value)) { - return ["".concat(key, "=fn").concat(value.name ? "<".concat(value.name, ">") : "")]; - } else { - value = toRaw(value); - return raw ? value : ["".concat(key, "="), value]; - } - } - - var ErrorTypeStrings = { - ["sp" - /* SERVER_PREFETCH */ - ]: 'serverPrefetch hook', - ["bc" - /* BEFORE_CREATE */ - ]: 'beforeCreate hook', - ["c" - /* CREATED */ - ]: 'created hook', - ["bm" - /* BEFORE_MOUNT */ - ]: 'beforeMount hook', - ["m" - /* MOUNTED */ - ]: 'mounted hook', - ["bu" - /* BEFORE_UPDATE */ - ]: 'beforeUpdate hook', - ["u" - /* UPDATED */ - ]: 'updated', - ["bum" - /* BEFORE_UNMOUNT */ - ]: 'beforeUnmount hook', - ["um" - /* UNMOUNTED */ - ]: 'unmounted hook', - ["a" - /* ACTIVATED */ - ]: 'activated hook', - ["da" - /* DEACTIVATED */ - ]: 'deactivated hook', - ["ec" - /* ERROR_CAPTURED */ - ]: 'errorCaptured hook', - ["rtc" - /* RENDER_TRACKED */ - ]: 'renderTracked hook', - ["rtg" - /* RENDER_TRIGGERED */ - ]: 'renderTriggered hook', - [0 - /* SETUP_FUNCTION */ - ]: 'setup function', - [1 - /* RENDER_FUNCTION */ - ]: 'render function', - [2 - /* WATCH_GETTER */ - ]: 'watcher getter', - [3 - /* WATCH_CALLBACK */ - ]: 'watcher callback', - [4 - /* WATCH_CLEANUP */ - ]: 'watcher cleanup function', - [5 - /* NATIVE_EVENT_HANDLER */ - ]: 'native event handler', - [6 - /* COMPONENT_EVENT_HANDLER */ - ]: 'component event handler', - [7 - /* VNODE_HOOK */ - ]: 'vnode hook', - [8 - /* DIRECTIVE_HOOK */ - ]: 'directive hook', - [9 - /* TRANSITION_HOOK */ - ]: 'transition hook', - [10 - /* APP_ERROR_HANDLER */ - ]: 'app errorHandler', - [11 - /* APP_WARN_HANDLER */ - ]: 'app warnHandler', - [12 - /* FUNCTION_REF */ - ]: 'ref function', - [13 - /* ASYNC_COMPONENT_LOADER */ - ]: 'async component loader', - [14 - /* SCHEDULER */ - ]: 'scheduler flush. This is likely a Vue internals bug. ' + 'Please open an issue at https://new-issue.vuejs.org/?repo=vuejs/core' - }; - - function callWithErrorHandling(fn, instance, type, args) { - var res; - - try { - res = args ? fn(...args) : fn(); - } catch (err) { - handleError(err, instance, type); - } - - return res; - } - - function callWithAsyncErrorHandling(fn, instance, type, args) { - if (isFunction(fn)) { - var res = callWithErrorHandling(fn, instance, type, args); - - if (res && isPromise(res)) { - res.catch(err => { - handleError(err, instance, type); - }); - } - - return res; - } + suspense.effects.length = 0; // discard previous container - var values = []; + suspense.hiddenContainer = createElement('div'); - for (var i = 0; i < fn.length; i++) { - values.push(callWithAsyncErrorHandling(fn[i], instance, type, args)); - } - - return values; - } + if (isInFallback) { + // already in fallback state + patch(null, newBranch, suspense.hiddenContainer, null, parentComponent, suspense, isSVG, slotScopeIds, optimized); - function handleError(err, instance, type) { - var throwInDev = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true; - var contextVNode = instance ? instance.vnode : null; - - if (instance) { - var cur = instance.parent; // the exposed instance is the render proxy to keep it consistent with 2.x + if (suspense.deps <= 0) { + suspense.resolve(); + } else { + patch(activeBranch, newFallback, container, anchor, parentComponent, null, // fallback tree will not have suspense context + isSVG, slotScopeIds, optimized); + setActiveBranch(suspense, newFallback); + } + } else if (activeBranch && isSameVNodeType(newBranch, activeBranch)) { + // toggled "back" to current active branch + patch(activeBranch, newBranch, container, anchor, parentComponent, suspense, isSVG, slotScopeIds, optimized); // force resolve - var exposedInstance = instance.proxy; // in production the hook receives only the error code - // fixed by xxxxxx + suspense.resolve(true); + } else { + // switched to a 3rd branch + patch(null, newBranch, suspense.hiddenContainer, null, parentComponent, suspense, isSVG, slotScopeIds, optimized); - var errorInfo = ErrorTypeStrings[type] || type; + if (suspense.deps <= 0) { + suspense.resolve(); + } + } + } + } else { + if (activeBranch && isSameVNodeType(newBranch, activeBranch)) { + // root did not change, just normal patch + patch(activeBranch, newBranch, container, anchor, parentComponent, suspense, isSVG, slotScopeIds, optimized); + setActiveBranch(suspense, newBranch); + } else { + // root node toggled + // invoke @pending event + triggerEvent(n2, 'onPending'); // mount pending branch in off-dom container - while (cur) { - var errorCapturedHooks = cur.ec; + suspense.pendingBranch = newBranch; + suspense.pendingId++; + patch(null, newBranch, suspense.hiddenContainer, null, parentComponent, suspense, isSVG, slotScopeIds, optimized); - if (errorCapturedHooks) { - for (var i = 0; i < errorCapturedHooks.length; i++) { - if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) { - return; + if (suspense.deps <= 0) { + // incoming branch has no async deps, resolve now. + suspense.resolve(); + } else { + var { + timeout, + pendingId + } = suspense; + + if (timeout > 0) { + setTimeout(() => { + if (suspense.pendingId === pendingId) { + suspense.fallback(newFallback); + } + }, timeout); + } else if (timeout === 0) { + suspense.fallback(newFallback); } } } + } + } - cur = cur.parent; - } // app-level handling + var hasWarned = false; + function createSuspenseBoundary(vnode, parent, parentComponent, container, hiddenContainer, anchor, isSVG, slotScopeIds, optimized, rendererInternals) { + var isHydrating = arguments.length > 10 && arguments[10] !== undefined ? arguments[10] : false; - var appErrorHandler = instance.appContext.config.errorHandler; + /* istanbul ignore if */ + if (!hasWarned) { + hasWarned = true; // @ts-ignore `console.info` cannot be null error - if (appErrorHandler) { - callWithErrorHandling(appErrorHandler, null, 10 - /* APP_ERROR_HANDLER */ - , [err, exposedInstance, errorInfo]); - return; + console[console.info ? 'info' : 'log'](" is an experimental feature and its API will likely change."); } - } - logError(err, type, contextVNode, throwInDev); - } + var { + p: patch, + m: move, + um: unmount, + n: next, + o: { + parentNode, + remove + } + } = rendererInternals; + var timeout = shared.toNumber(vnode.props && vnode.props.timeout); + var suspense = { + vnode, + parent, + parentComponent, + isSVG, + container, + hiddenContainer, + anchor, + deps: 0, + pendingId: 0, + timeout: typeof timeout === 'number' ? timeout : -1, + activeBranch: null, + pendingBranch: null, + isInFallback: true, + isHydrating, + isUnmounted: false, + effects: [], + + resolve() { + var resume = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; + { + if (!resume && !suspense.pendingBranch) { + throw new Error("suspense.resolve() is called without a pending branch."); + } - function logError(err, type, contextVNode) { - var throwInDev = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true; - { - var info = ErrorTypeStrings[type] || type; // fixed by xxxxxx + if (suspense.isUnmounted) { + throw new Error("suspense.resolve() is called on an already unmounted suspense boundary."); + } + } + var { + vnode, + activeBranch, + pendingBranch, + pendingId, + effects, + parentComponent, + container + } = suspense; - if (contextVNode) { - pushWarningContext(contextVNode); - } + if (suspense.isHydrating) { + suspense.isHydrating = false; + } else if (!resume) { + var delayEnter = activeBranch && pendingBranch.transition && pendingBranch.transition.mode === 'out-in'; + + if (delayEnter) { + activeBranch.transition.afterLeave = () => { + if (pendingId === suspense.pendingId) { + move(pendingBranch, container, _anchor, 0 + /* ENTER */ + ); + } + }; + } // this is initial anchor on mount - warn$1("Unhandled error".concat(info ? " during execution of ".concat(info) : "")); - if (contextVNode) { - popWarningContext(); - } // crash in dev by default so it's more noticeable + var { + anchor: _anchor + } = suspense; // unmount current active tree + if (activeBranch) { + // if the fallback tree was mounted, it may have been moved + // as part of a parent suspense. get the latest anchor for insertion + _anchor = next(activeBranch); + unmount(activeBranch, parentComponent, suspense, true); + } - if (throwInDev) { - throw err; - } else { - console.error(err); - } - } - } - - var isFlushing = false; - var isFlushPending = false; - var queue = []; - var flushIndex = 0; - var pendingPreFlushCbs = []; - var activePreFlushCbs = null; - var preFlushIndex = 0; - var pendingPostFlushCbs = []; - var activePostFlushCbs = null; - var postFlushIndex = 0; - var resolvedPromise = Promise.resolve(); - var currentFlushPromise = null; - var currentPreFlushParentJob = null; - var RECURSION_LIMIT = 100; - - function nextTick(fn) { - var p = currentFlushPromise || resolvedPromise; - return fn ? p.then(this ? fn.bind(this) : fn) : p; - } // #2768 - // Use binary-search to find a suitable position in the queue, - // so that the queue maintains the increasing order of job's id, - // which can prevent the job from being skipped and also can avoid repeated patching. - - - function findInsertionIndex(id) { - // the start index should be `flushIndex + 1` - var start = flushIndex + 1; - var end = queue.length; - - while (start < end) { - var middle = start + end >>> 1; - var middleJobId = getId(queue[middle]); - middleJobId < id ? start = middle + 1 : end = middle; - } - - return start; - } - - function queueJob(job) { - // the dedupe search uses the startIndex argument of Array.includes() - // by default the search index includes the current job that is being run - // so it cannot recursively trigger itself again. - // if the job is a watch() callback, the search will start with a +1 index to - // allow it recursively trigger itself - it is the user's responsibility to - // ensure it doesn't end up in an infinite loop. - if ((!queue.length || !queue.includes(job, isFlushing && job.allowRecurse ? flushIndex + 1 : flushIndex)) && job !== currentPreFlushParentJob) { - if (job.id == null) { - queue.push(job); - } else { - queue.splice(findInsertionIndex(job.id), 0, job); - } + if (!delayEnter) { + // move content from off-dom container to actual container + move(pendingBranch, container, _anchor, 0 + /* ENTER */ + ); + } + } - queueFlush(); - } - } + setActiveBranch(suspense, pendingBranch); + suspense.pendingBranch = null; + suspense.isInFallback = false; // flush buffered effects + // check if there is a pending parent suspense - function queueFlush() { - if (!isFlushing && !isFlushPending) { - isFlushPending = true; - currentFlushPromise = resolvedPromise.then(flushJobs); - } - } + var parent = suspense.parent; + var hasUnresolvedAncestor = false; - function invalidateJob(job) { - var i = queue.indexOf(job); + while (parent) { + if (parent.pendingBranch) { + // found a pending parent suspense, merge buffered post jobs + // into that parent + parent.effects.push(...effects); + hasUnresolvedAncestor = true; + break; + } - if (i > flushIndex) { - queue.splice(i, 1); - } - } + parent = parent.parent; + } // no pending parent suspense, flush all jobs - 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(); - } + if (!hasUnresolvedAncestor) { + queuePostFlushCb(effects); + } - function queuePreFlushCb(cb) { - queueCb(cb, activePreFlushCbs, pendingPreFlushCbs, preFlushIndex); - } + suspense.effects = []; // invoke @resolve event - function queuePostFlushCb(cb) { - queueCb(cb, activePostFlushCbs, pendingPostFlushCbs, postFlushIndex); - } + triggerEvent(vnode, 'onResolve'); + }, - function flushPreFlushCbs(seen) { - var parentJob = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null; + fallback(fallbackVNode) { + if (!suspense.pendingBranch) { + return; + } - if (pendingPreFlushCbs.length) { - currentPreFlushParentJob = parentJob; - activePreFlushCbs = [...new Set(pendingPreFlushCbs)]; - pendingPreFlushCbs.length = 0; - { - seen = seen || new Map(); - } + var { + vnode, + activeBranch, + parentComponent, + container, + isSVG + } = suspense; // invoke @fallback event + + triggerEvent(vnode, 'onFallback'); + var anchor = next(activeBranch); + + var mountFallback = () => { + if (!suspense.isInFallback) { + return; + } // mount the fallback tree - for (preFlushIndex = 0; preFlushIndex < activePreFlushCbs.length; preFlushIndex++) { - if (checkRecursiveUpdates(seen, activePreFlushCbs[preFlushIndex])) { - continue; - } - activePreFlushCbs[preFlushIndex](); - } + patch(null, fallbackVNode, container, anchor, parentComponent, null, // fallback tree will not have suspense context + isSVG, slotScopeIds, optimized); + setActiveBranch(suspense, fallbackVNode); + }; - activePreFlushCbs = null; - preFlushIndex = 0; - currentPreFlushParentJob = null; // recursively flush until it drains + var delayEnter = fallbackVNode.transition && fallbackVNode.transition.mode === 'out-in'; - flushPreFlushCbs(seen, parentJob); - } - } + if (delayEnter) { + activeBranch.transition.afterLeave = mountFallback; + } - function flushPostFlushCbs(seen) { - if (pendingPostFlushCbs.length) { - var deduped = [...new Set(pendingPostFlushCbs)]; - pendingPostFlushCbs.length = 0; // #1947 already has active queue, nested flushPostFlushCbs call + suspense.isInFallback = true; // unmount current active branch - if (activePostFlushCbs) { - activePostFlushCbs.push(...deduped); - return; - } + unmount(activeBranch, parentComponent, null, // no suspense so unmount hooks fire now + true // shouldRemove + ); - activePostFlushCbs = deduped; - { - seen = seen || new Map(); - } - activePostFlushCbs.sort((a, b) => getId(a) - getId(b)); + if (!delayEnter) { + mountFallback(); + } + }, - for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) { - if (checkRecursiveUpdates(seen, activePostFlushCbs[postFlushIndex])) { - continue; - } + move(container, anchor, type) { + suspense.activeBranch && move(suspense.activeBranch, container, anchor, type); + suspense.container = container; + }, - activePostFlushCbs[postFlushIndex](); - } + next() { + return suspense.activeBranch && next(suspense.activeBranch); + }, - activePostFlushCbs = null; - postFlushIndex = 0; - } - } + registerDep(instance, setupRenderEffect) { + var isInPendingSuspense = !!suspense.pendingBranch; - var getId = job => job.id == null ? Infinity : job.id; + if (isInPendingSuspense) { + suspense.deps++; + } - function flushJobs(seen) { - isFlushPending = false; - isFlushing = true; - { - seen = seen || new Map(); - } - flushPreFlushCbs(seen); // Sort queue before flush. - // This ensures that: - // 1. Components are updated from parent to child. (because parent is always - // created before the child so its render effect will have smaller - // priority number) - // 2. If a component is unmounted during a parent component's update, - // its update can be skipped. - - queue.sort((a, b) => getId(a) - getId(b)); // conditional usage of checkRecursiveUpdate must be determined out of - // try ... catch block since Rollup by default de-optimizes treeshaking - // inside try-catch. This can leave all warning code unshaked. Although - // they would get eventually shaken by a minifier like terser, some minifiers - // would fail to do that (e.g. https://github.com/evanw/esbuild/issues/1610) - - var check = job => checkRecursiveUpdates(seen, job); - - try { - for (flushIndex = 0; flushIndex < queue.length; flushIndex++) { - var job = queue[flushIndex]; - - if (job && job.active !== false) { - if ("development" !== 'production' && check(job)) { - continue; - } // console.log(`running:`, job.id) + var hydratedEl = instance.vnode.el; + instance.asyncDep.catch(err => { + handleError(err, instance, 0 + /* SETUP_FUNCTION */ + ); + }).then(asyncSetupResult => { + // retry when the setup() promise resolves. + // component may have been unmounted before resolve. + if (instance.isUnmounted || suspense.isUnmounted || suspense.pendingId !== instance.suspenseId) { + return; + } // retry from this component - callWithErrorHandling(job, null, 14 - /* SCHEDULER */ - ); - } - } - } finally { - flushIndex = 0; - queue.length = 0; - flushPostFlushCbs(seen); - isFlushing = false; - currentFlushPromise = null; // some postFlushCb queued jobs! - // keep flushing until it drains. + instance.asyncResolved = true; + var { + vnode + } = instance; + { + pushWarningContext(vnode); + } + handleSetupResult(instance, asyncSetupResult, false); - if (queue.length || pendingPreFlushCbs.length || pendingPostFlushCbs.length) { - flushJobs(seen); - } - } - } + if (hydratedEl) { + // vnode may have been replaced if an update happened before the + // async dep is resolved. + vnode.el = hydratedEl; + } - function checkRecursiveUpdates(seen, fn) { - if (!seen.has(fn)) { - seen.set(fn, 1); - } else { - var count = seen.get(fn); + var placeholder = !hydratedEl && instance.subTree.el; + setupRenderEffect(instance, vnode, // component may have been moved before resolve. + // if this is not a hydration, instance.subTree will be the comment + // placeholder. + parentNode(hydratedEl || instance.subTree.el), // anchor will not be used if this is hydration, so only need to + // consider the comment placeholder case. + hydratedEl ? null : next(instance.subTree), suspense, isSVG, optimized); - if (count > RECURSION_LIMIT) { - var instance = fn.ownerInstance; - var componentName = instance && getComponentName(instance.type); - warn$1("Maximum recursive updates exceeded".concat(componentName ? " in component <".concat(componentName, ">") : "", ". ") + "This means you have a reactive effect that is mutating its own " + "dependencies and thus recursively triggering itself. Possible sources " + "include component template, render function, updated hook or " + "watcher source function."); - return true; - } else { - seen.set(fn, count + 1); - } - } - } - /* eslint-disable no-restricted-globals */ + if (placeholder) { + remove(placeholder); + } + updateHOCHostEl(instance, vnode.el); + { + popWarningContext(); + } // only decrease deps count if suspense is not already resolved + + if (isInPendingSuspense && --suspense.deps === 0) { + suspense.resolve(); + } + }); + }, - var isHmrUpdating = false; - var hmrDirtyComponents = new Set(); // Expose the HMR runtime on the global object - // This makes it entirely tree-shakable without polluting the exports and makes - // it easier to be used in toolings like vue-loader - // Note: for a component to be eligible for HMR it also needs the __hmrId option - // to be set so that its instances can be registered / removed. + unmount(parentSuspense, doRemove) { + suspense.isUnmounted = true; - { - getGlobalThis().__VUE_HMR_RUNTIME__ = { - createRecord: tryWrap(createRecord), - rerender: tryWrap(rerender), - reload: tryWrap(reload) - }; - } - var map = new Map(); + if (suspense.activeBranch) { + unmount(suspense.activeBranch, parentComponent, parentSuspense, doRemove); + } - function registerHMR(instance) { - var id = instance.type.__hmrId; - var record = map.get(id); + if (suspense.pendingBranch) { + unmount(suspense.pendingBranch, parentComponent, parentSuspense, doRemove); + } + } - if (!record) { - createRecord(id, instance.type); - record = map.get(id); + }; + return suspense; } - record.instances.add(instance); - } + function hydrateSuspense(node, vnode, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, rendererInternals, hydrateNode) { + /* eslint-disable no-restricted-globals */ + var suspense = vnode.suspense = createSuspenseBoundary(vnode, parentSuspense, parentComponent, node.parentNode, document.createElement('div'), null, isSVG, slotScopeIds, optimized, rendererInternals, true + /* hydrating */ + ); // there are two possible scenarios for server-rendered suspense: + // - success: ssr content should be fully resolved + // - failure: ssr content should be the fallback branch. + // however, on the client we don't really know if it has failed or not + // attempt to hydrate the DOM assuming it has succeeded, but we still + // need to construct a suspense boundary first - function unregisterHMR(instance) { - map.get(instance.type.__hmrId).instances.delete(instance); - } + var result = hydrateNode(node, suspense.pendingBranch = vnode.ssContent, parentComponent, suspense, slotScopeIds, optimized); - function createRecord(id, initialDef) { - if (map.has(id)) { - return false; + if (suspense.deps === 0) { + suspense.resolve(); + } + + return result; + /* eslint-enable no-restricted-globals */ } - map.set(id, { - initialDef: normalizeClassComponent(initialDef), - instances: new Set() - }); - return true; - } + function normalizeSuspenseChildren(vnode) { + var { + shapeFlag, + children + } = vnode; + var isSlotChildren = shapeFlag & 32 + /* SLOTS_CHILDREN */ + ; + vnode.ssContent = normalizeSuspenseSlot(isSlotChildren ? children.default : children); + vnode.ssFallback = isSlotChildren ? normalizeSuspenseSlot(children.fallback) : createVNode(Comment); + } - function normalizeClassComponent(component) { - return isClassComponent(component) ? component.__vccOpts : component; - } + function normalizeSuspenseSlot(s) { + var block; - function rerender(id, newRender) { - var record = map.get(id); + if (shared.isFunction(s)) { + var trackBlock = isBlockTreeEnabled && s._c; - if (!record) { - return; - } // update initial record (for not-yet-rendered component) + if (trackBlock) { + // disableTracking: false + // allow block tracking for compiled slots + // (see ./componentRenderContext.ts) + s._d = false; + openBlock(); + } + s = s(); - record.initialDef.render = newRender; - [...record.instances].forEach(instance => { - if (newRender) { - instance.render = newRender; - normalizeClassComponent(instance.type).render = newRender; + if (trackBlock) { + s._d = true; + block = currentBlock; + closeBlock(); + } } - instance.renderCache = []; // this flag forces child components with slot content to update - - isHmrUpdating = true; - instance.update(); - isHmrUpdating = false; - }); - } - - function reload(id, newComp) { - var record = map.get(id); - if (!record) return; - newComp = normalizeClassComponent(newComp); // update initial def (for not-yet-rendered components) - - updateComponentDef(record.initialDef, newComp); // create a snapshot which avoids the set being mutated during updates + if (shared.isArray(s)) { + var singleChild = filterSingleRoot(s); - var instances = [...record.instances]; + if (!singleChild) { + warn(" slots expect a single root node."); + } - for (var instance of instances) { - var oldComp = normalizeClassComponent(instance.type); + s = singleChild; + } - if (!hmrDirtyComponents.has(oldComp)) { - // 1. Update existing comp definition to match new one - if (oldComp !== record.initialDef) { - updateComponentDef(oldComp, newComp); - } // 2. mark definition dirty. This forces the renderer to replace the - // component on patch. + s = normalizeVNode(s); + if (block && !s.dynamicChildren) { + s.dynamicChildren = block.filter(c => c !== s); + } - hmrDirtyComponents.add(oldComp); - } // 3. invalidate options resolution cache + return s; + } + function queueEffectWithSuspense(fn, suspense) { + if (suspense && suspense.pendingBranch) { + if (shared.isArray(fn)) { + suspense.effects.push(...fn); + } else { + suspense.effects.push(fn); + } + } else { + queuePostFlushCb(fn); + } + } - instance.appContext.optionsCache.delete(instance.type); // 4. actually update + function setActiveBranch(suspense, branch) { + suspense.activeBranch = branch; + var { + vnode, + parentComponent + } = suspense; + var el = vnode.el = branch.el; // in case suspense is the root node of a component, + // recursively update the HOC el - if (instance.ceReload) { - // custom element - hmrDirtyComponents.add(oldComp); - instance.ceReload(newComp.styles); - hmrDirtyComponents.delete(oldComp); - } else if (instance.parent) { - // 4. Force the parent instance to re-render. This will cause all updated - // components to be unmounted and re-mounted. Queue the update so that we - // don't end up forcing the same parent to re-render multiple times. - queueJob(instance.parent.update); // instance is the inner component of an async custom element - // invoke to reset styles + if (parentComponent && parentComponent.subTree === vnode) { + parentComponent.vnode.el = el; + updateHOCHostEl(parentComponent, el); + } + } - if (instance.parent.type.__asyncLoader && instance.parent.ceReload) { - instance.parent.ceReload(newComp.styles); + function provide(key, value) { + if (!currentInstance) { + { + warn("provide() can only be used inside setup()."); } - } else if (instance.appContext.reload) { - // root instance mounted via createApp() has a reload method - instance.appContext.reload(); - } else if (typeof window !== 'undefined') { - // root instance inside tree created via raw render(). Force reload. - window.location.reload(); } else { - console.warn('[HMR] Root or manually mounted instance modified. Full reload required.'); - } - } // 5. make sure to cleanup dirty hmr components after update + var provides = currentInstance.provides; // by default an instance inherits its parent's provides object + // but when it needs to provide values of its own, it creates its + // own provides object using parent provides object as prototype. + // this way in `inject` we can simply look up injections from direct + // parent and let the prototype chain do the work. + var parentProvides = currentInstance.parent && currentInstance.parent.provides; - queuePostFlushCb(() => { - for (var _instance of instances) { - hmrDirtyComponents.delete(normalizeClassComponent(_instance.type)); - } - }); - } + if (parentProvides === provides) { + provides = currentInstance.provides = Object.create(parentProvides); + } // TS doesn't allow symbol as index type - function updateComponentDef(oldComp, newComp) { - extend(oldComp, newComp); - for (var key in oldComp) { - if (key !== '__file' && !(key in newComp)) { - delete oldComp[key]; + provides[key] = value; } } - } - function tryWrap(fn) { - return (id, arg) => { - try { - return fn(id, arg); - } catch (e) { - console.error(e); - console.warn("[HMR] Something went wrong during Vue component hot-reload. " + "Full reload required."); + function inject(key, defaultValue) { + var treatDefaultAsFactory = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; + // fallback to `currentRenderingInstance` so that this can be called in + // a functional component + var instance = currentInstance || currentRenderingInstance; + + if (instance) { + // #2400 + // to support `app.use` plugins, + // fallback to appContext's `provides` if the instance is at root + var provides = instance.parent == null ? instance.vnode.appContext && instance.vnode.appContext.provides : instance.parent.provides; + + if (provides && key in provides) { + // TS doesn't allow symbol as index type + return provides[key]; + } else if (arguments.length > 1) { + return treatDefaultAsFactory && shared.isFunction(defaultValue) ? defaultValue.call(instance.proxy) : defaultValue; + } else { + warn("injection \"".concat(String(key), "\" not found.")); + } + } else { + warn("inject() can only be used inside setup() or functional components."); } - }; - } + } // Simple effect. - var devtools; - var buffer = []; - var devtoolsNotInstalled = false; - function emit(event) { - for (var _len5 = arguments.length, args = new Array(_len5 > 1 ? _len5 - 1 : 0), _key6 = 1; _key6 < _len5; _key6++) { - args[_key6 - 1] = arguments[_key6]; + function watchEffect(effect, options) { + return doWatch(effect, null, options); } - if (devtools) { - devtools.emit(event, ...args); - } else if (!devtoolsNotInstalled) { - buffer.push({ - event, - args - }); + function watchPostEffect(effect, options) { + return doWatch(effect, null, Object.assign(options || {}, { + flush: 'post' + })); } - } - - function setDevtoolsHook(hook, target) { - var _a, _b; - devtools = hook; + function watchSyncEffect(effect, options) { + return doWatch(effect, null, Object.assign(options || {}, { + flush: 'sync' + })); + } // initial value for watchers to trigger on undefined initial values - if (devtools) { - devtools.enabled = true; - buffer.forEach(_ref5 => { - var { - event, - args - } = _ref5; - return devtools.emit(event, ...args); - }); - buffer = []; - } else if ( // handle late devtools injection - only do this if we are in an actual - // browser environment to avoid the timer handle stalling test runner exit - // (#4815) - // eslint-disable-next-line no-restricted-globals - typeof window !== 'undefined' && // some envs mock window but not fully - window.HTMLElement && // also exclude jsdom - !((_b = (_a = window.navigator) === null || _a === void 0 ? void 0 : _a.userAgent) === null || _b === void 0 ? void 0 : _b.includes('jsdom'))) { - var replay = target.__VUE_DEVTOOLS_HOOK_REPLAY__ = target.__VUE_DEVTOOLS_HOOK_REPLAY__ || []; - replay.push(newHook => { - setDevtoolsHook(newHook, target); - }); // clear buffer after 3s - the user probably doesn't have devtools installed - // at all, and keeping the buffer will cause memory leaks (#4738) - - setTimeout(() => { - if (!devtools) { - target.__VUE_DEVTOOLS_HOOK_REPLAY__ = null; - devtoolsNotInstalled = true; - buffer = []; - } - }, 3000); - } else { - // non-browser env, assume not installed - devtoolsNotInstalled = true; - buffer = []; - } - } - - function devtoolsInitApp(app, version) { - emit("app:init" - /* APP_INIT */ - , app, version, { - Fragment, - Text, - Comment, - Static - }); - } - - function devtoolsUnmountApp(app) { - emit("app:unmount" - /* APP_UNMOUNT */ - , app); - } - - var devtoolsComponentAdded = /*#__PURE__*/createDevtoolsComponentHook("component:added" - /* COMPONENT_ADDED */ - ); - var devtoolsComponentUpdated = /*#__PURE__*/createDevtoolsComponentHook("component:updated" - /* COMPONENT_UPDATED */ - ); - var devtoolsComponentRemoved = /*#__PURE__*/createDevtoolsComponentHook("component:removed" - /* COMPONENT_REMOVED */ - ); - - function createDevtoolsComponentHook(hook) { - return component => { - emit(hook, component.appContext.app, component.uid, component.parent ? component.parent.uid : undefined, component); - }; - } - - var devtoolsPerfStart = /*#__PURE__*/createDevtoolsPerformanceHook("perf:start" - /* PERFORMANCE_START */ - ); - var devtoolsPerfEnd = /*#__PURE__*/createDevtoolsPerformanceHook("perf:end" - /* PERFORMANCE_END */ - ); - - function createDevtoolsPerformanceHook(hook) { - return (component, type, time) => { - emit(hook, component.appContext.app, component.uid, component, type, time); - }; - } - function devtoolsComponentEmit(component, event, params) { - emit("component:emit" - /* COMPONENT_EMIT */ - , component.appContext.app, component, event, params); - } + var INITIAL_WATCHER_VALUE = {}; // implementation - function emit$1(instance, event) { - var props = instance.vnode.props || EMPTY_OBJ; + function watch(source, cb, options) { + if (!shared.isFunction(cb)) { + warn("`watch(fn, options?)` signature has been moved to a separate API. " + "Use `watchEffect(fn, options?)` instead. `watch` now only " + "supports `watch(source, cb, options?) signature."); + } - for (var _len6 = arguments.length, rawArgs = new Array(_len6 > 2 ? _len6 - 2 : 0), _key7 = 2; _key7 < _len6; _key7++) { - rawArgs[_key7 - 2] = arguments[_key7]; + return doWatch(source, cb, options); } - { + function doWatch(source, cb) { var { - emitsOptions, - propsOptions: [propsOptions] - } = instance; + immediate, + deep, + flush, + onTrack, + onTrigger + } = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : shared.EMPTY_OBJ; + + if (!cb) { + if (immediate !== undefined) { + warn("watch() \"immediate\" option is only respected when using the " + "watch(source, callback, options?) signature."); + } + + if (deep !== undefined) { + warn("watch() \"deep\" option is only respected when using the " + "watch(source, callback, options?) signature."); + } + } - if (emitsOptions) { - if (!(event in emitsOptions) && !false) { - if (!propsOptions || !(toHandlerKey(event) in propsOptions)) { - warn$1("Component emitted event \"".concat(event, "\" but it is neither declared in ") + "the emits option nor as an \"".concat(toHandlerKey(event), "\" prop.")); + var warnInvalidSource = s => { + warn("Invalid watch source: ", s, "A watch source can only be a getter/effect function, a ref, " + "a reactive object, or an array of these types."); + }; + + var instance = currentInstance; + var getter; + var forceTrigger = false; + var isMultiSource = false; + + if (reactivity.isRef(source)) { + getter = () => source.value; + + forceTrigger = reactivity.isShallow(source); + } else if (reactivity.isReactive(source)) { + getter = () => source; + + deep = true; + } else if (shared.isArray(source)) { + isMultiSource = true; + forceTrigger = source.some(reactivity.isReactive); + + getter = () => source.map(s => { + if (reactivity.isRef(s)) { + return s.value; + } else if (reactivity.isReactive(s)) { + return traverse(s); + } else if (shared.isFunction(s)) { + return callWithErrorHandling(s, instance, 2 + /* WATCH_GETTER */ + ); + } else { + warnInvalidSource(s); } + }); + } else if (shared.isFunction(source)) { + if (cb) { + // getter with cb + getter = () => callWithErrorHandling(source, instance, 2 + /* WATCH_GETTER */ + ); } else { - var validator = emitsOptions[event]; - - if (isFunction(validator)) { - var isValid = validator(...rawArgs); + // no cb -> simple effect + getter = () => { + if (instance && instance.isUnmounted) { + return; + } - if (!isValid) { - warn$1("Invalid event arguments: event validation failed for event \"".concat(event, "\".")); + if (cleanup) { + cleanup(); } - } + + return callWithAsyncErrorHandling(source, instance, 3 + /* WATCH_CALLBACK */ + , [onCleanup]); + }; } + } else { + getter = shared.NOOP; + warnInvalidSource(source); } - } - var args = rawArgs; - var isModelListener = event.startsWith('update:'); // for v-model update:xxx events, apply modifiers on args - - var modelArg = isModelListener && event.slice(7); - if (modelArg && modelArg in props) { - var modifiersKey = "".concat(modelArg === 'modelValue' ? 'model' : modelArg, "Modifiers"); - var { - number, - trim - } = props[modifiersKey] || EMPTY_OBJ; + if (cb && deep) { + var baseGetter = getter; - if (trim) { - args = rawArgs.map(a => a.trim()); - } else if (number) { - args = rawArgs.map(toNumber); + getter = () => traverse(baseGetter()); } - } - { - devtoolsComponentEmit(instance, event, args); - } - { - var lowerCaseEvent = event.toLowerCase(); + var cleanup; - if (lowerCaseEvent !== event && props[toHandlerKey(lowerCaseEvent)]) { - warn$1("Event \"".concat(lowerCaseEvent, "\" is emitted in component ") + "".concat(formatComponentName(instance, instance.type), " but the handler is registered for \"").concat(event, "\". ") + "Note that HTML attributes are case-insensitive and you cannot use " + "v-on to listen to camelCase events when using in-DOM templates. " + "You should probably use \"".concat(hyphenate(event), "\" instead of \"").concat(event, "\".")); - } - } - var handlerName; - var handler = props[handlerName = toHandlerKey(event)] || // also try camelCase event handler (#2249) - props[handlerName = toHandlerKey(camelize(event))]; // for v-model update:xxx events, also trigger kebab-case equivalent - // for props passed via kebab-case + var onCleanup = fn => { + cleanup = effect.onStop = () => { + callWithErrorHandling(fn, instance, 4 + /* WATCH_CLEANUP */ + ); + }; + }; // in SSR there is no need to setup an actual effect, and it should be noop + // unless it's eager - if (!handler && isModelListener) { - handler = props[handlerName = toHandlerKey(hyphenate(event))]; - } - if (handler) { - callWithAsyncErrorHandling(handler, instance, 6 - /* COMPONENT_EVENT_HANDLER */ - , args); - } + if (isInSSRComponentSetup) { + // we will also not call the invalidate callback (+ runner is not set up) + onCleanup = shared.NOOP; - var onceHandler = props[handlerName + "Once"]; + if (!cb) { + getter(); + } else if (immediate) { + callWithAsyncErrorHandling(cb, instance, 3 + /* WATCH_CALLBACK */ + , [getter(), isMultiSource ? [] : undefined, onCleanup]); + } - if (onceHandler) { - if (!instance.emitted) { - instance.emitted = {}; - } else if (instance.emitted[handlerName]) { - return; + return shared.NOOP; } - instance.emitted[handlerName] = true; - callWithAsyncErrorHandling(onceHandler, instance, 6 - /* COMPONENT_EVENT_HANDLER */ - , args); - } - } + var oldValue = isMultiSource ? [] : INITIAL_WATCHER_VALUE; - function normalizeEmitsOptions(comp, appContext) { - var asMixin = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; - var cache = appContext.emitsCache; - var cached = cache.get(comp); + var job = () => { + if (!effect.active) { + return; + } - if (cached !== undefined) { - return cached; - } + if (cb) { + // watch(source, cb) + var newValue = effect.run(); - var raw = comp.emits; - var normalized = {}; // apply mixin/extends props + if (deep || forceTrigger || (isMultiSource ? newValue.some((v, i) => shared.hasChanged(v, oldValue[i])) : shared.hasChanged(newValue, oldValue)) || false) { + // cleanup before running cb again + if (cleanup) { + cleanup(); + } - var hasExtends = false; + callWithAsyncErrorHandling(cb, instance, 3 + /* WATCH_CALLBACK */ + , [newValue, // pass undefined as the old value when it's changed for the first time + oldValue === INITIAL_WATCHER_VALUE ? undefined : oldValue, onCleanup]); + oldValue = newValue; + } + } else { + // watchEffect + effect.run(); + } + }; // important: mark the job as a watcher callback so that scheduler knows + // it is allowed to self-trigger (#1727) - if (!isFunction(comp)) { - var extendEmits = raw => { - var normalizedFromExtend = normalizeEmitsOptions(raw, appContext, true); - if (normalizedFromExtend) { - hasExtends = true; - extend(normalized, normalizedFromExtend); - } - }; + job.allowRecurse = !!cb; + var scheduler; - if (!asMixin && appContext.mixins.length) { - appContext.mixins.forEach(extendEmits); + if (flush === 'sync') { + scheduler = job; // the scheduler function gets called directly + } else if (flush === 'post') { + scheduler = () => queuePostRenderEffect(job, instance && instance.suspense); + } else { + // default: 'pre' + scheduler = () => { + if (!instance || instance.isMounted) { + queuePreFlushCb(job); + } else { + // with 'pre' option, the first call must happen before + // the component is mounted so it is called synchronously. + job(); + } + }; } - if (comp.extends) { - extendEmits(comp.extends); - } + var effect = new reactivity.ReactiveEffect(getter, scheduler); + { + effect.onTrack = onTrack; + effect.onTrigger = onTrigger; + } // initial run - if (comp.mixins) { - comp.mixins.forEach(extendEmits); + if (cb) { + if (immediate) { + job(); + } else { + oldValue = effect.run(); + } + } else if (flush === 'post') { + queuePostRenderEffect(effect.run.bind(effect), instance && instance.suspense); + } else { + effect.run(); } - } - - if (!raw && !hasExtends) { - cache.set(comp, null); - return null; - } - if (isArray(raw)) { - raw.forEach(key => normalized[key] = null); - } else { - extend(normalized, raw); - } + return () => { + effect.stop(); - cache.set(comp, normalized); - return normalized; - } // Check if an incoming prop key is a declared emit event listener. - // e.g. With `emits: { click: null }`, props named `onClick` and `onclick` are - // both considered matched listeners. + if (instance && instance.scope) { + shared.remove(instance.scope.effects, effect); + } + }; + } // this.$watch - function isEmitListener(options, key) { - if (!options || !isOn(key)) { - return false; - } + function instanceWatch(source, value, options) { + var publicThis = this.proxy; + var getter = shared.isString(source) ? source.includes('.') ? createPathGetter(publicThis, source) : () => publicThis[source] : source.bind(publicThis, publicThis); + var cb; - key = key.slice(2).replace(/Once$/, ''); - return hasOwn(options, key[0].toLowerCase() + key.slice(1)) || hasOwn(options, hyphenate(key)) || hasOwn(options, key); - } - /** - * mark the current rendering instance for asset resolution (e.g. - * resolveComponent, resolveDirective) during render - */ - - - var currentRenderingInstance = null; - var currentScopeId = null; - /** - * Note: rendering calls maybe nested. The function returns the parent rendering - * instance if present, which should be restored after the render is done: - * - * ```js - * const prev = setCurrentRenderingInstance(i) - * // ...render - * setCurrentRenderingInstance(prev) - * ``` - */ - - function setCurrentRenderingInstance(instance) { - var prev = currentRenderingInstance; - currentRenderingInstance = instance; - currentScopeId = instance && instance.type.__scopeId || null; - return prev; - } - /** - * Set scope id when creating hoisted vnodes. - * @private compiler helper - */ - - - function pushScopeId(id) { - currentScopeId = id; - } - /** - * Technically we no longer need this after 3.0.8 but we need to keep the same - * API for backwards compat w/ code generated by compilers. - * @private - */ - - - function popScopeId() { - currentScopeId = null; - } - /** - * Only for backwards compat - * @private - */ - - - var withScopeId = _id => withCtx; - /** - * Wrap a slot function to memoize current rendering instance - * @private compiler helper - */ - - - function withCtx(fn) { - var ctx = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : currentRenderingInstance; - var isNonScopedSlot // false only - = arguments.length > 2 ? arguments[2] : undefined; - if (!ctx) return fn; // already normalized - - if (fn._n) { - return fn; - } - - var renderFnWithContext = function () { - // If a user calls a compiled slot inside a template expression (#1745), it - // can mess up block tracking, so by default we disable block tracking and - // force bail out when invoking a compiled slot (indicated by the ._d flag). - // This isn't necessary if rendering a compiled ``, so we flip the - // ._d flag off when invoking the wrapped fn inside `renderSlot`. - if (renderFnWithContext._d) { - setBlockTracking(-1); - } - - var prevInstance = setCurrentRenderingInstance(ctx); - var res = fn(...arguments); - setCurrentRenderingInstance(prevInstance); - - if (renderFnWithContext._d) { - setBlockTracking(1); + if (shared.isFunction(value)) { + cb = value; + } else { + cb = value.handler; + options = value; } - { - devtoolsComponentUpdated(ctx); + var cur = currentInstance; + setCurrentInstance(this); + var res = doWatch(getter, cb.bind(publicThis), options); + + if (cur) { + setCurrentInstance(cur); + } else { + unsetCurrentInstance(); } + return res; - }; // mark normalized to avoid duplicated wrapping - - - renderFnWithContext._n = true; // mark this as compiled by default - // this is used in vnode.ts -> normalizeChildren() to set the slot - // rendering flag. - - renderFnWithContext._c = true; // disable block tracking by default - - renderFnWithContext._d = true; - return renderFnWithContext; - } - /** - * dev only flag to track whether $attrs was used during render. - * If $attrs was used during render then the warning for failed attrs - * fallthrough can be suppressed. - */ - - - var accessedAttrs = false; - - function markAttrsAccessed() { - accessedAttrs = true; - } - - function renderComponentRoot(instance) { - var { - type: Component, - vnode, - proxy, - withProxy, - props, - propsOptions: [propsOptions], - slots, - attrs, - emit, - render, - renderCache, - data, - setupState, - ctx, - inheritAttrs - } = instance; - var result; - var fallthroughAttrs; - var prev = setCurrentRenderingInstance(instance); - { - accessedAttrs = false; } - try { - if (vnode.shapeFlag & 4 - /* STATEFUL_COMPONENT */ - ) { - // withProxy is a proxy with a different `has` trap only for - // runtime-compiled render functions using `with` block. - var proxyToUse = withProxy || proxy; - result = normalizeVNode(render.call(proxyToUse, proxyToUse, renderCache, props, setupState, data, ctx)); - fallthroughAttrs = attrs; - } else { - // functional - var _render = Component; // in dev, mark attrs accessed if optional props (attrs === props) + function createPathGetter(ctx, path) { + var segments = path.split('.'); + return () => { + var cur = ctx; - if ("development" !== 'production' && attrs === props) { - markAttrsAccessed(); + for (var i = 0; i < segments.length && cur; i++) { + cur = cur[segments[i]]; } - result = normalizeVNode(_render.length > 1 ? _render(props, "development" !== '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); - } - } catch (err) { - blockStack.length = 0; - handleError(err, instance, 1 - /* RENDER_FUNCTION */ - ); - result = createVNode(Comment); - } // 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 - - - var root = result; - var setRoot = undefined; - - if (result.patchFlag > 0 && result.patchFlag & 2048 - /* DEV_ROOT_FRAGMENT */ - ) { - [root, setRoot] = getChildRoot(result); + return cur; + }; } - if (fallthroughAttrs && inheritAttrs !== false) { - var keys = Object.keys(fallthroughAttrs); - var { - shapeFlag - } = root; - - if (keys.length) { - if (shapeFlag & (1 - /* ELEMENT */ - | 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 (!accessedAttrs && root.type !== Comment) { - var allAttrs = Object.keys(attrs); - var eventAttrs = []; - var extraAttrs = []; - - for (var i = 0, l = allAttrs.length; i < l; i++) { - var key = allAttrs[i]; - - if (isOn(key)) { - // ignore v-model handlers when they fail to fallthrough - if (!isModelListener(key)) { - // remove `on`, lowercase first letter to reflect event casing - // accurately - eventAttrs.push(key[2].toLowerCase() + key.slice(3)); - } - } else { - extraAttrs.push(key); - } - } - - if (extraAttrs.length) { - warn$1("Extraneous non-props attributes (" + "".concat(extraAttrs.join(', '), ") ") + "were passed to component but could not be automatically inherited " + "because component renders fragment or text root nodes."); - } - - if (eventAttrs.length) { - warn$1("Extraneous non-emits event listeners (" + "".concat(eventAttrs.join(', '), ") ") + "were passed to component but could not be automatically inherited " + "because component renders fragment or text root nodes. " + "If the listener is intended to be a component custom event listener only, " + "declare it using the \"emits\" option."); - } - } + function traverse(value, seen) { + if (!shared.isObject(value) || value["__v_skip" + /* SKIP */ + ]) { + return value; } - } // inherit directives + seen = seen || new Set(); - if (vnode.dirs) { - if (!isElementRoot(root)) { - warn$1("Runtime directive used on component with non-element root node. " + "The directives will not function as intended."); + if (seen.has(value)) { + return value; } - root.dirs = root.dirs ? root.dirs.concat(vnode.dirs) : vnode.dirs; - } // inherit transition data + seen.add(value); - - if (vnode.transition) { - if (!isElementRoot(root)) { - warn$1("Component inside renders non-element root node " + "that cannot be animated."); + if (reactivity.isRef(value)) { + traverse(value.value, seen); + } else if (shared.isArray(value)) { + for (var i = 0; i < value.length; i++) { + traverse(value[i], seen); + } + } else if (shared.isSet(value) || shared.isMap(value)) { + value.forEach(v => { + traverse(v, seen); + }); + } else if (shared.isPlainObject(value)) { + for (var key in value) { + traverse(value[key], seen); + } } - root.transition = vnode.transition; + return value; } - if (setRoot) { - setRoot(root); - } else { - result = root; - } + function useTransitionState() { + var state = { + isMounted: false, + isLeaving: false, + isUnmounting: false, + leavingVNodes: new Map() + }; + onMounted(() => { + state.isMounted = true; + }); + onBeforeUnmount(() => { + state.isUnmounting = true; + }); + return state; + } + + var TransitionHookValidator = [Function, Array]; + var BaseTransitionImpl = { + name: "BaseTransition", + props: { + mode: String, + appear: Boolean, + persisted: Boolean, + // enter + onBeforeEnter: TransitionHookValidator, + onEnter: TransitionHookValidator, + onAfterEnter: TransitionHookValidator, + onEnterCancelled: TransitionHookValidator, + // leave + onBeforeLeave: TransitionHookValidator, + onLeave: TransitionHookValidator, + onAfterLeave: TransitionHookValidator, + onLeaveCancelled: TransitionHookValidator, + // appear + onBeforeAppear: TransitionHookValidator, + onAppear: TransitionHookValidator, + onAfterAppear: TransitionHookValidator, + onAppearCancelled: TransitionHookValidator + }, - setCurrentRenderingInstance(prev); - return result; - } - /** - * dev only - * In dev mode, template root level comments are rendered, which turns the - * template into a fragment root, but we need to locate the single element - * root for attrs and scope id processing. - */ + setup(props, _ref6) { + var { + slots + } = _ref6; + var instance = getCurrentInstance(); + var state = useTransitionState(); + var prevTransitionKey; + return () => { + var children = slots.default && getTransitionRawChildren(slots.default(), true); + if (!children || !children.length) { + return; + } // warn multiple elements - var getChildRoot = vnode => { - var rawChildren = vnode.children; - var dynamicChildren = vnode.dynamicChildren; - var childRoot = filterSingleRoot(rawChildren); - if (!childRoot) { - return [vnode, undefined]; - } + if (children.length > 1) { + warn(' can only be used on a single element or component. Use ' + ' for lists.'); + } // there's no need to track reactivity for these props so use the raw + // props for a bit better perf - var index = rawChildren.indexOf(childRoot); - var dynamicIndex = dynamicChildren ? dynamicChildren.indexOf(childRoot) : -1; - var setRoot = updatedRoot => { - rawChildren[index] = updatedRoot; + var rawProps = reactivity.toRaw(props); + var { + mode + } = rawProps; // check mode - if (dynamicChildren) { - if (dynamicIndex > -1) { - dynamicChildren[dynamicIndex] = updatedRoot; - } else if (updatedRoot.patchFlag > 0) { - vnode.dynamicChildren = [...dynamicChildren, updatedRoot]; - } - } - }; + if (mode && mode !== 'in-out' && mode !== 'out-in' && mode !== 'default') { + warn("invalid mode: ".concat(mode)); + } // at this point children has a guaranteed length of 1. - return [normalizeVNode(childRoot), setRoot]; - }; - function filterSingleRoot(children) { - var singleRoot; + var child = children[0]; - for (var i = 0; i < children.length; i++) { - var child = children[i]; + if (state.isLeaving) { + return emptyPlaceholder(child); + } // in the case of , we need to + // compare the type of the kept-alive children. - if (isVNode(child)) { - // ignore user comment - if (child.type !== Comment || child.children === 'v-if') { - if (singleRoot) { - // has more than 1 non-comment child, return now - return; - } else { - singleRoot = child; - } - } - } else { - return; - } - } - return singleRoot; - } + var innerChild = getKeepAliveChild(child); - var getFunctionalFallthrough = attrs => { - var res; + if (!innerChild) { + return emptyPlaceholder(child); + } - for (var key in attrs) { - if (key === 'class' || key === 'style' || isOn(key)) { - (res || (res = {}))[key] = attrs[key]; - } - } + var enterHooks = resolveTransitionHooks(innerChild, rawProps, state, instance); + setTransitionHooks(innerChild, enterHooks); + var oldChild = instance.subTree; + var oldInnerChild = oldChild && getKeepAliveChild(oldChild); + var transitionKeyChanged = false; + var { + getTransitionKey + } = innerChild.type; - return res; - }; + if (getTransitionKey) { + var key = getTransitionKey(); - var filterModelListeners = (attrs, props) => { - var res = {}; + if (prevTransitionKey === undefined) { + prevTransitionKey = key; + } else if (key !== prevTransitionKey) { + prevTransitionKey = key; + transitionKeyChanged = true; + } + } // handle mode - for (var key in attrs) { - if (!isModelListener(key) || !(key.slice(9) in props)) { - res[key] = attrs[key]; - } - } - return res; - }; + if (oldInnerChild && oldInnerChild.type !== Comment && (!isSameVNodeType(innerChild, oldInnerChild) || transitionKeyChanged)) { + var leavingHooks = resolveTransitionHooks(oldInnerChild, rawProps, state, instance); // update old tree's hooks in case of dynamic transition - var isElementRoot = vnode => { - return vnode.shapeFlag & (6 - /* COMPONENT */ - | 1 - /* ELEMENT */ - ) || vnode.type === Comment // potential v-if branch switch - ; - }; + setTransitionHooks(oldInnerChild, leavingHooks); // switching between different views - function shouldUpdateComponent(prevVNode, nextVNode, optimized) { - var { - props: prevProps, - children: prevChildren, - component - } = prevVNode; - var { - props: nextProps, - children: nextChildren, - patchFlag - } = nextVNode; - var emits = component.emitsOptions; // Parent component's render function was hot-updated. Since this may have - // caused the child component's slots content to have changed, we need to - // force the child to update as well. + if (mode === 'out-in') { + state.isLeaving = true; // return placeholder node and queue update when leave finishes - if ((prevChildren || nextChildren) && isHmrUpdating) { - return true; - } // force child update for runtime directive or transition on component vnode. + leavingHooks.afterLeave = () => { + state.isLeaving = false; + instance.update(); + }; + return emptyPlaceholder(child); + } else if (mode === 'in-out' && innerChild.type !== Comment) { + leavingHooks.delayLeave = (el, earlyRemove, delayedLeave) => { + var leavingVNodesCache = getLeavingNodesForType(state, oldInnerChild); + leavingVNodesCache[String(oldInnerChild.key)] = oldInnerChild; // early removal callback - if (nextVNode.dirs || nextVNode.transition) { - return true; - } + el._leaveCb = () => { + earlyRemove(); + el._leaveCb = undefined; + delete enterHooks.delayedLeave; + }; - 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; - } + enterHooks.delayedLeave = delayedLeave; + }; + } + } - if (patchFlag & 16 - /* FULL_PROPS */ - ) { - if (!prevProps) { - return !!nextProps; - } // presence of this flag indicates props are always non-null + return child; + }; + } + }; // export the public type for h/tsx inference + // also to avoid inline import() in generated d.ts files - return hasPropsChanged(prevProps, nextProps, emits); - } else if (patchFlag & 8 - /* PROPS */ - ) { - var dynamicProps = nextVNode.dynamicProps; + var BaseTransition = BaseTransitionImpl; - for (var i = 0; i < dynamicProps.length; i++) { - var key = dynamicProps[i]; + function getLeavingNodesForType(state, vnode) { + var { + leavingVNodes + } = state; + var leavingVNodesCache = leavingVNodes.get(vnode.type); - 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 (!leavingVNodesCache) { + leavingVNodesCache = Object.create(null); + leavingVNodes.set(vnode.type, leavingVNodesCache); } - if (prevProps === nextProps) { - return false; - } + return leavingVNodesCache; + } // The transition hooks are attached to the vnode as vnode.transition + // and will be called at appropriate timing in the renderer. - if (!prevProps) { - return !!nextProps; - } - if (!nextProps) { - return true; - } + function resolveTransitionHooks(vnode, props, state, instance) { + var { + appear, + mode, + persisted = false, + onBeforeEnter, + onEnter, + onAfterEnter, + onEnterCancelled, + onBeforeLeave, + onLeave, + onAfterLeave, + onLeaveCancelled, + onBeforeAppear, + onAppear, + onAfterAppear, + onAppearCancelled + } = props; + var key = String(vnode.key); + var leavingVNodesCache = getLeavingNodesForType(state, vnode); - return hasPropsChanged(prevProps, nextProps, emits); - } + var callHook = (hook, args) => { + hook && callWithAsyncErrorHandling(hook, instance, 9 + /* TRANSITION_HOOK */ + , args); + }; - return false; - } + var hooks = { + mode, + persisted, - function hasPropsChanged(prevProps, nextProps, emitsOptions) { - var nextKeys = Object.keys(nextProps); + beforeEnter(el) { + var hook = onBeforeEnter; - if (nextKeys.length !== Object.keys(prevProps).length) { - return true; - } + if (!state.isMounted) { + if (appear) { + hook = onBeforeAppear || onBeforeEnter; + } else { + return; + } + } // for same element (v-show) - for (var i = 0; i < nextKeys.length; i++) { - var key = nextKeys[i]; - if (nextProps[key] !== prevProps[key] && !isEmitListener(emitsOptions, key)) { - return true; - } - } + if (el._leaveCb) { + el._leaveCb(true + /* cancelled */ + ); + } // for toggled element with same key (v-if) - return false; - } - function updateHOCHostEl(_ref6, el // HostNode - ) { - var { - vnode, - parent - } = _ref6; + var leavingVNode = leavingVNodesCache[key]; - while (parent && parent.subTree === vnode) { - (vnode = parent.vnode).el = el; - parent = parent.parent; - } - } + if (leavingVNode && isSameVNodeType(vnode, leavingVNode) && leavingVNode.el._leaveCb) { + // force early removal (not cancelled) + leavingVNode.el._leaveCb(); + } - var isSuspense = type => type.__isSuspense; // Suspense exposes a component-like API, and is treated like a component - // in the compiler, but internally it's a special built-in type that hooks - // directly into the renderer. + callHook(hook, [el]); + }, + enter(el) { + var hook = onEnter; + var afterHook = onAfterEnter; + var cancelHook = onEnterCancelled; - var SuspenseImpl = { - name: 'Suspense', - // In order to make Suspense tree-shakable, we need to avoid importing it - // directly in the renderer. The renderer checks for the __isSuspense flag - // on a vnode's type and calls the `process` method, passing in renderer - // internals. - __isSuspense: true, + if (!state.isMounted) { + if (appear) { + hook = onAppear || onEnter; + afterHook = onAfterAppear || onAfterEnter; + cancelHook = onAppearCancelled || onEnterCancelled; + } else { + return; + } + } - process(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, // platform-specific impl passed from renderer - rendererInternals) { - if (n1 == null) { - mountSuspense(n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, rendererInternals); - } else { - patchSuspense(n1, n2, container, anchor, parentComponent, isSVG, slotScopeIds, optimized, rendererInternals); - } - }, - - hydrate: hydrateSuspense, - create: createSuspenseBoundary, - normalize: normalizeSuspenseChildren - }; // Force-casted public typing for h and TSX props inference - - var Suspense = SuspenseImpl; - - function triggerEvent(vnode, name) { - var eventListener = vnode.props && vnode.props[name]; - - if (isFunction(eventListener)) { - eventListener(); - } - } - - function mountSuspense(vnode, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, rendererInternals) { - var { - p: patch, - o: { - createElement - } - } = rendererInternals; - var hiddenContainer = createElement('div'); - var suspense = vnode.suspense = createSuspenseBoundary(vnode, parentSuspense, parentComponent, container, hiddenContainer, anchor, isSVG, slotScopeIds, optimized, rendererInternals); // start mounting the content subtree in an off-dom container - - patch(null, suspense.pendingBranch = vnode.ssContent, hiddenContainer, null, parentComponent, suspense, isSVG, slotScopeIds); // now check if we have encountered any async deps - - if (suspense.deps > 0) { - // has async - // invoke @fallback event - triggerEvent(vnode, 'onPending'); - triggerEvent(vnode, 'onFallback'); // mount the fallback tree - - patch(null, vnode.ssFallback, container, anchor, parentComponent, null, // fallback tree will not have suspense context - isSVG, slotScopeIds); - setActiveBranch(suspense, vnode.ssFallback); - } else { - // Suspense has no async deps. Just resolve. - suspense.resolve(); - } - } - - function patchSuspense(n1, n2, container, anchor, parentComponent, isSVG, slotScopeIds, optimized, _ref7) { - var { - p: patch, - um: unmount, - o: { - createElement - } - } = _ref7; - var suspense = n2.suspense = n1.suspense; - suspense.vnode = n2; - n2.el = n1.el; - var newBranch = n2.ssContent; - var newFallback = n2.ssFallback; - var { - activeBranch, - pendingBranch, - isInFallback, - isHydrating - } = suspense; - - if (pendingBranch) { - suspense.pendingBranch = newBranch; - - if (isSameVNodeType(newBranch, pendingBranch)) { - // same root type but content may have changed. - patch(pendingBranch, newBranch, suspense.hiddenContainer, null, parentComponent, suspense, isSVG, slotScopeIds, optimized); - - if (suspense.deps <= 0) { - suspense.resolve(); - } else if (isInFallback) { - patch(activeBranch, newFallback, container, anchor, parentComponent, null, // fallback tree will not have suspense context - isSVG, slotScopeIds, optimized); - setActiveBranch(suspense, newFallback); - } - } else { - // toggled before pending tree is resolved - suspense.pendingId++; - - if (isHydrating) { - // if toggled before hydration is finished, the current DOM tree is - // no longer valid. set it as the active branch so it will be unmounted - // when resolved - suspense.isHydrating = false; - suspense.activeBranch = pendingBranch; - } else { - unmount(pendingBranch, parentComponent, suspense); - } // increment pending ID. this is used to invalidate async callbacks - // reset suspense state + var called = false; + var done = el._enterCb = cancelled => { + if (called) return; + called = true; - suspense.deps = 0; // discard effects from pending branch + if (cancelled) { + callHook(cancelHook, [el]); + } else { + callHook(afterHook, [el]); + } - suspense.effects.length = 0; // discard previous container + if (hooks.delayedLeave) { + hooks.delayedLeave(); + } - suspense.hiddenContainer = createElement('div'); + el._enterCb = undefined; + }; - if (isInFallback) { - // already in fallback state - patch(null, newBranch, suspense.hiddenContainer, null, parentComponent, suspense, isSVG, slotScopeIds, optimized); + if (hook) { + hook(el, done); - if (suspense.deps <= 0) { - suspense.resolve(); + if (hook.length <= 1) { + done(); + } } else { - patch(activeBranch, newFallback, container, anchor, parentComponent, null, // fallback tree will not have suspense context - isSVG, slotScopeIds, optimized); - setActiveBranch(suspense, newFallback); + done(); } - } else if (activeBranch && isSameVNodeType(newBranch, activeBranch)) { - // toggled "back" to current active branch - patch(activeBranch, newBranch, container, anchor, parentComponent, suspense, isSVG, slotScopeIds, optimized); // force resolve + }, - suspense.resolve(true); - } else { - // switched to a 3rd branch - patch(null, newBranch, suspense.hiddenContainer, null, parentComponent, suspense, isSVG, slotScopeIds, optimized); + leave(el, remove) { + var key = String(vnode.key); - if (suspense.deps <= 0) { - suspense.resolve(); + if (el._enterCb) { + el._enterCb(true + /* cancelled */ + ); } - } - } - } else { - if (activeBranch && isSameVNodeType(newBranch, activeBranch)) { - // root did not change, just normal patch - patch(activeBranch, newBranch, container, anchor, parentComponent, suspense, isSVG, slotScopeIds, optimized); - setActiveBranch(suspense, newBranch); - } else { - // root node toggled - // invoke @pending event - triggerEvent(n2, 'onPending'); // mount pending branch in off-dom container - suspense.pendingBranch = newBranch; - suspense.pendingId++; - patch(null, newBranch, suspense.hiddenContainer, null, parentComponent, suspense, isSVG, slotScopeIds, optimized); + if (state.isUnmounting) { + return remove(); + } - if (suspense.deps <= 0) { - // incoming branch has no async deps, resolve now. - suspense.resolve(); - } else { - var { - timeout, - pendingId - } = suspense; + callHook(onBeforeLeave, [el]); + var called = false; - if (timeout > 0) { - setTimeout(() => { - if (suspense.pendingId === pendingId) { - suspense.fallback(newFallback); - } - }, timeout); - } else if (timeout === 0) { - suspense.fallback(newFallback); - } - } - } - } - } + var done = el._leaveCb = cancelled => { + if (called) return; + called = true; + remove(); - var hasWarned = false; + if (cancelled) { + callHook(onLeaveCancelled, [el]); + } else { + callHook(onAfterLeave, [el]); + } - function createSuspenseBoundary(vnode, parent, parentComponent, container, hiddenContainer, anchor, isSVG, slotScopeIds, optimized, rendererInternals) { - var isHydrating = arguments.length > 10 && arguments[10] !== undefined ? arguments[10] : false; + el._leaveCb = undefined; - /* istanbul ignore if */ - if (!hasWarned) { - hasWarned = true; // @ts-ignore `console.info` cannot be null error + if (leavingVNodesCache[key] === vnode) { + delete leavingVNodesCache[key]; + } + }; - console[console.info ? 'info' : 'log'](" is an experimental feature and its API will likely change."); - } + leavingVNodesCache[key] = vnode; - var { - p: patch, - m: move, - um: unmount, - n: next, - o: { - parentNode, - remove - } - } = rendererInternals; - var timeout = toNumber(vnode.props && vnode.props.timeout); - var suspense = { - vnode, - parent, - parentComponent, - isSVG, - container, - hiddenContainer, - anchor, - deps: 0, - pendingId: 0, - timeout: typeof timeout === 'number' ? timeout : -1, - activeBranch: null, - pendingBranch: null, - isInFallback: true, - isHydrating, - isUnmounted: false, - effects: [], + if (onLeave) { + onLeave(el, done); - resolve() { - var resume = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; - { - if (!resume && !suspense.pendingBranch) { - throw new Error("suspense.resolve() is called without a pending branch."); + if (onLeave.length <= 1) { + done(); + } + } else { + done(); } + }, - if (suspense.isUnmounted) { - throw new Error("suspense.resolve() is called on an already unmounted suspense boundary."); - } + clone(vnode) { + return resolveTransitionHooks(vnode, props, state, instance); } - var { - vnode, - activeBranch, - pendingBranch, - pendingId, - effects, - parentComponent, - container - } = suspense; - - if (suspense.isHydrating) { - suspense.isHydrating = false; - } else if (!resume) { - var delayEnter = activeBranch && pendingBranch.transition && pendingBranch.transition.mode === 'out-in'; - - if (delayEnter) { - activeBranch.transition.afterLeave = () => { - if (pendingId === suspense.pendingId) { - move(pendingBranch, container, _anchor, 0 - /* ENTER */ - ); - } - }; - } // this is initial anchor on mount + }; + return hooks; + } // the placeholder really only handles one special case: KeepAlive + // in the case of a KeepAlive in a leave phase we need to return a KeepAlive + // placeholder with empty content to avoid the KeepAlive instance from being + // unmounted. - var { - anchor: _anchor - } = suspense; // unmount current active tree - if (activeBranch) { - // if the fallback tree was mounted, it may have been moved - // as part of a parent suspense. get the latest anchor for insertion - _anchor = next(activeBranch); - unmount(activeBranch, parentComponent, suspense, true); - } + function emptyPlaceholder(vnode) { + if (isKeepAlive(vnode)) { + vnode = cloneVNode(vnode); + vnode.children = null; + return vnode; + } + } - if (!delayEnter) { - // move content from off-dom container to actual container - move(pendingBranch, container, _anchor, 0 - /* ENTER */ - ); - } - } + function getKeepAliveChild(vnode) { + return isKeepAlive(vnode) ? vnode.children ? vnode.children[0] : undefined : vnode; + } - setActiveBranch(suspense, pendingBranch); - suspense.pendingBranch = null; - suspense.isInFallback = false; // flush buffered effects - // check if there is a pending parent suspense + function setTransitionHooks(vnode, hooks) { + if (vnode.shapeFlag & 6 + /* COMPONENT */ + && vnode.component) { + setTransitionHooks(vnode.component.subTree, hooks); + } else if (vnode.shapeFlag & 128 + /* SUSPENSE */ + ) { + vnode.ssContent.transition = hooks.clone(vnode.ssContent); + vnode.ssFallback.transition = hooks.clone(vnode.ssFallback); + } else { + vnode.transition = hooks; + } + } - var parent = suspense.parent; - var hasUnresolvedAncestor = false; + function getTransitionRawChildren(children) { + var keepComment = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; + var ret = []; + var keyedFragmentCount = 0; - while (parent) { - if (parent.pendingBranch) { - // found a pending parent suspense, merge buffered post jobs - // into that parent - parent.effects.push(...effects); - hasUnresolvedAncestor = true; - break; - } + for (var i = 0; i < children.length; i++) { + var child = children[i]; // handle fragment children case, e.g. v-for - parent = parent.parent; - } // no pending parent suspense, flush all jobs + if (child.type === Fragment) { + if (child.patchFlag & 128 + /* KEYED_FRAGMENT */ + ) keyedFragmentCount++; + ret = ret.concat(getTransitionRawChildren(child.children, keepComment)); + } // comment placeholders should be skipped, e.g. v-if + else if (keepComment || child.type !== Comment) { + ret.push(child); + } + } // #1126 if a transition children list contains multiple sub fragments, these + // fragments will be merged into a flat children array. Since each v-for + // fragment may contain different static bindings inside, we need to de-op + // these children to force full diffs to ensure correct behavior. - if (!hasUnresolvedAncestor) { - queuePostFlushCb(effects); + if (keyedFragmentCount > 1) { + for (var _i = 0; _i < ret.length; _i++) { + ret[_i].patchFlag = -2 + /* BAIL */ + ; } + } - suspense.effects = []; // invoke @resolve event - - triggerEvent(vnode, 'onResolve'); - }, + return ret; + } // implementation, close to no-op - fallback(fallbackVNode) { - if (!suspense.pendingBranch) { - return; - } - var { - vnode, - activeBranch, - parentComponent, - container, - isSVG - } = suspense; // invoke @fallback event - - triggerEvent(vnode, 'onFallback'); - var anchor = next(activeBranch); - - var mountFallback = () => { - if (!suspense.isInFallback) { - return; - } // mount the fallback tree + function defineComponent(options) { + return shared.isFunction(options) ? { + setup: options, + name: options.name + } : options; + } + var isAsyncWrapper = i => !!i.type.__asyncLoader; - patch(null, fallbackVNode, container, anchor, parentComponent, null, // fallback tree will not have suspense context - isSVG, slotScopeIds, optimized); - setActiveBranch(suspense, fallbackVNode); + function defineAsyncComponent(source) { + if (shared.isFunction(source)) { + source = { + loader: source }; + } - var delayEnter = fallbackVNode.transition && fallbackVNode.transition.mode === 'out-in'; + var { + loader, + loadingComponent, + errorComponent, + delay = 200, + timeout, + // undefined = never times out + suspensible = true, + onError: userOnError + } = source; + var pendingRequest = null; + var resolvedComp; + var retries = 0; + + var retry = () => { + retries++; + pendingRequest = null; + return load(); + }; - if (delayEnter) { - activeBranch.transition.afterLeave = mountFallback; - } + var load = () => { + var thisRequest; + return pendingRequest || (thisRequest = pendingRequest = loader().catch(err => { + err = err instanceof Error ? err : new Error(String(err)); - suspense.isInFallback = true; // unmount current active branch + if (userOnError) { + return new Promise((resolve, reject) => { + var userRetry = () => resolve(retry()); - unmount(activeBranch, parentComponent, null, // no suspense so unmount hooks fire now - true // shouldRemove - ); + var userFail = () => reject(err); - if (!delayEnter) { - mountFallback(); - } - }, + userOnError(err, userRetry, userFail, retries + 1); + }); + } else { + throw err; + } + }).then(comp => { + if (thisRequest !== pendingRequest && pendingRequest) { + return pendingRequest; + } - move(container, anchor, type) { - suspense.activeBranch && move(suspense.activeBranch, container, anchor, type); - suspense.container = container; - }, + if (!comp) { + warn("Async component loader resolved to undefined. " + "If you are using retry(), make sure to return its return value."); + } // interop module default - next() { - return suspense.activeBranch && next(suspense.activeBranch); - }, - registerDep(instance, setupRenderEffect) { - var isInPendingSuspense = !!suspense.pendingBranch; + if (comp && (comp.__esModule || comp[Symbol.toStringTag] === 'Module')) { + comp = comp.default; + } - if (isInPendingSuspense) { - suspense.deps++; - } + if (comp && !shared.isObject(comp) && !shared.isFunction(comp)) { + throw new Error("Invalid async component load result: ".concat(comp)); + } - var hydratedEl = instance.vnode.el; - instance.asyncDep.catch(err => { - handleError(err, instance, 0 - /* SETUP_FUNCTION */ - ); - }).then(asyncSetupResult => { - // retry when the setup() promise resolves. - // component may have been unmounted before resolve. - if (instance.isUnmounted || suspense.isUnmounted || suspense.pendingId !== instance.suspenseId) { - return; - } // retry from this component + resolvedComp = comp; + return comp; + })); + }; + return defineComponent({ + name: 'AsyncComponentWrapper', + __asyncLoader: load, - instance.asyncResolved = true; - var { - vnode - } = instance; - { - pushWarningContext(vnode); - } - handleSetupResult(instance, asyncSetupResult, false); + get __asyncResolved() { + return resolvedComp; + }, + + setup() { + var instance = currentInstance; // already resolved - if (hydratedEl) { - // vnode may have been replaced if an update happened before the - // async dep is resolved. - vnode.el = hydratedEl; + if (resolvedComp) { + return () => createInnerComp(resolvedComp, instance); } - var placeholder = !hydratedEl && instance.subTree.el; - setupRenderEffect(instance, vnode, // component may have been moved before resolve. - // if this is not a hydration, instance.subTree will be the comment - // placeholder. - parentNode(hydratedEl || instance.subTree.el), // anchor will not be used if this is hydration, so only need to - // consider the comment placeholder case. - hydratedEl ? null : next(instance.subTree), suspense, isSVG, optimized); + var onError = err => { + pendingRequest = null; + handleError(err, instance, 13 + /* ASYNC_COMPONENT_LOADER */ + , !errorComponent + /* do not throw in dev if user provided error component */ + ); + }; // suspense-controlled or SSR. + - if (placeholder) { - remove(placeholder); + if (suspensible && instance.suspense || isInSSRComponentSetup) { + return load().then(comp => { + return () => createInnerComp(comp, instance); + }).catch(err => { + onError(err); + return () => errorComponent ? createVNode(errorComponent, { + error: err + }) : null; + }); } - updateHOCHostEl(instance, vnode.el); - { - popWarningContext(); - } // only decrease deps count if suspense is not already resolved + var loaded = reactivity.ref(false); + var error = reactivity.ref(); + var delayed = reactivity.ref(!!delay); - if (isInPendingSuspense && --suspense.deps === 0) { - suspense.resolve(); + if (delay) { + setTimeout(() => { + delayed.value = false; + }, delay); } - }); - }, - unmount(parentSuspense, doRemove) { - suspense.isUnmounted = true; + if (timeout != null) { + setTimeout(() => { + if (!loaded.value && !error.value) { + var err = new Error("Async component timed out after ".concat(timeout, "ms.")); + onError(err); + error.value = err; + } + }, timeout); + } - if (suspense.activeBranch) { - unmount(suspense.activeBranch, parentComponent, parentSuspense, doRemove); - } + load().then(() => { + loaded.value = true; - if (suspense.pendingBranch) { - unmount(suspense.pendingBranch, parentComponent, parentSuspense, doRemove); + if (instance.parent && isKeepAlive(instance.parent.vnode)) { + // parent is keep-alive, force update so the loaded component's + // name is taken into account + queueJob(instance.parent.update); + } + }).catch(err => { + onError(err); + error.value = err; + }); + return () => { + if (loaded.value && resolvedComp) { + return createInnerComp(resolvedComp, instance); + } else if (error.value && errorComponent) { + return createVNode(errorComponent, { + error: error.value + }); + } else if (loadingComponent && !delayed.value) { + return createVNode(loadingComponent); + } + }; } - } - }; - return suspense; - } - - function hydrateSuspense(node, vnode, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, rendererInternals, hydrateNode) { - /* eslint-disable no-restricted-globals */ - var suspense = vnode.suspense = createSuspenseBoundary(vnode, parentSuspense, parentComponent, node.parentNode, document.createElement('div'), null, isSVG, slotScopeIds, optimized, rendererInternals, true - /* hydrating */ - ); // there are two possible scenarios for server-rendered suspense: - // - success: ssr content should be fully resolved - // - failure: ssr content should be the fallback branch. - // however, on the client we don't really know if it has failed or not - // attempt to hydrate the DOM assuming it has succeeded, but we still - // need to construct a suspense boundary first - - var result = hydrateNode(node, suspense.pendingBranch = vnode.ssContent, parentComponent, suspense, slotScopeIds, optimized); - - if (suspense.deps === 0) { - suspense.resolve(); + }); } - return result; - /* eslint-enable no-restricted-globals */ - } - - function normalizeSuspenseChildren(vnode) { - var { - shapeFlag, - children - } = vnode; - var isSlotChildren = shapeFlag & 32 - /* SLOTS_CHILDREN */ - ; - vnode.ssContent = normalizeSuspenseSlot(isSlotChildren ? children.default : children); - vnode.ssFallback = isSlotChildren ? normalizeSuspenseSlot(children.fallback) : createVNode(Comment); - } + function createInnerComp(comp, _ref7) { + var { + vnode: { + ref, + props, + children + } + } = _ref7; + var vnode = createVNode(comp, props, children); // ensure inner component inherits the async wrapper's ref owner - function normalizeSuspenseSlot(s) { - var block; + vnode.ref = ref; + return vnode; + } - if (isFunction(s)) { - var trackBlock = isBlockTreeEnabled && s._c; + var isKeepAlive = vnode => vnode.type.__isKeepAlive; - if (trackBlock) { - // disableTracking: false - // allow block tracking for compiled slots - // (see ./componentRenderContext.ts) - s._d = false; - openBlock(); - } + var KeepAliveImpl = { + name: "KeepAlive", + // Marker for special handling inside the renderer. We are not using a === + // check directly on KeepAlive in the renderer, because importing it directly + // would prevent it from being tree-shaken. + __isKeepAlive: true, + props: { + include: [String, RegExp, Array], + exclude: [String, RegExp, Array], + max: [String, Number] + }, - s = s(); + setup(props, _ref8) { + var { + slots + } = _ref8; + var instance = getCurrentInstance(); // KeepAlive communicates with the instantiated renderer via the + // ctx where the renderer passes in its internals, + // and the KeepAlive instance exposes activate/deactivate implementations. + // The whole point of this is to avoid importing KeepAlive directly in the + // renderer to facilitate tree-shaking. - if (trackBlock) { - s._d = true; - block = currentBlock; - closeBlock(); - } - } + var sharedContext = instance.ctx; // if the internal renderer is not registered, it indicates that this is server-side rendering, + // for KeepAlive, we just need to render its children - if (isArray(s)) { - var singleChild = filterSingleRoot(s); + if (!sharedContext.renderer) { + return slots.default; + } - if (!singleChild) { - warn$1(" slots expect a single root node."); - } + var cache = new Map(); + var keys = new Set(); + var current = null; + { + instance.__v_cache = cache; + } + var parentSuspense = instance.suspense; + var { + renderer: { + p: patch, + m: move, + um: _unmount, + o: { + createElement + } + } + } = sharedContext; + var storageContainer = createElement('div'); - s = singleChild; - } + sharedContext.activate = (vnode, container, anchor, isSVG, optimized) => { + var instance = vnode.component; + move(vnode, container, anchor, 0 + /* ENTER */ + , parentSuspense); // in case props have changed - s = normalizeVNode(s); + patch(instance.vnode, vnode, container, anchor, instance, parentSuspense, isSVG, vnode.slotScopeIds, optimized); + queuePostRenderEffect(() => { + instance.isDeactivated = false; - if (block && !s.dynamicChildren) { - s.dynamicChildren = block.filter(c => c !== s); - } + if (instance.a) { + shared.invokeArrayFns(instance.a); + } - return s; - } + var vnodeHook = vnode.props && vnode.props.onVnodeMounted; - function queueEffectWithSuspense(fn, suspense) { - if (suspense && suspense.pendingBranch) { - if (isArray(fn)) { - suspense.effects.push(...fn); - } else { - suspense.effects.push(fn); - } - } else { - queuePostFlushCb(fn); - } - } + if (vnodeHook) { + invokeVNodeHook(vnodeHook, instance.parent, vnode); + } + }, parentSuspense); + { + // Update components tree + devtoolsComponentAdded(instance); + } + }; - function setActiveBranch(suspense, branch) { - suspense.activeBranch = branch; - var { - vnode, - parentComponent - } = suspense; - var el = vnode.el = branch.el; // in case suspense is the root node of a component, - // recursively update the HOC el + sharedContext.deactivate = vnode => { + var instance = vnode.component; + move(vnode, storageContainer, null, 1 + /* LEAVE */ + , parentSuspense); + queuePostRenderEffect(() => { + if (instance.da) { + shared.invokeArrayFns(instance.da); + } - if (parentComponent && parentComponent.subTree === vnode) { - parentComponent.vnode.el = el; - updateHOCHostEl(parentComponent, el); - } - } + var vnodeHook = vnode.props && vnode.props.onVnodeUnmounted; - function provide(key, value) { - if (!currentInstance) { - { - warn$1("provide() can only be used inside setup()."); - } - } else { - var provides = currentInstance.provides; // by default an instance inherits its parent's provides object - // but when it needs to provide values of its own, it creates its - // own provides object using parent provides object as prototype. - // this way in `inject` we can simply look up injections from direct - // parent and let the prototype chain do the work. + if (vnodeHook) { + invokeVNodeHook(vnodeHook, instance.parent, vnode); + } - var parentProvides = currentInstance.parent && currentInstance.parent.provides; + instance.isDeactivated = true; + }, parentSuspense); + { + // Update components tree + devtoolsComponentAdded(instance); + } + }; - if (parentProvides === provides) { - provides = currentInstance.provides = Object.create(parentProvides); - } // TS doesn't allow symbol as index type + function unmount(vnode) { + // reset the shapeFlag so it can be properly unmounted + resetShapeFlag(vnode); + _unmount(vnode, instance, parentSuspense, true); + } - provides[key] = value; - } - } + function pruneCache(filter) { + cache.forEach((vnode, key) => { + var name = getComponentName(vnode.type); - function inject(key, defaultValue) { - var treatDefaultAsFactory = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; - // fallback to `currentRenderingInstance` so that this can be called in - // a functional component - var instance = currentInstance || currentRenderingInstance; + if (name && (!filter || !filter(name))) { + pruneCacheEntry(key); + } + }); + } - if (instance) { - // #2400 - // to support `app.use` plugins, - // fallback to appContext's `provides` if the instance is at root - var provides = instance.parent == null ? instance.vnode.appContext && instance.vnode.appContext.provides : instance.parent.provides; + function pruneCacheEntry(key) { + var cached = cache.get(key); - if (provides && key in provides) { - // TS doesn't allow symbol as index type - return provides[key]; - } else if (arguments.length > 1) { - return treatDefaultAsFactory && isFunction(defaultValue) ? defaultValue.call(instance.proxy) : defaultValue; - } else { - warn$1("injection \"".concat(String(key), "\" not found.")); - } - } else { - warn$1("inject() can only be used inside setup() or functional components."); - } - } // Simple effect. + if (!current || cached.type !== current.type) { + unmount(cached); + } else if (current) { + // current active instance should no longer be kept-alive. + // we can't unmount it now but it might be later, so reset its flag now. + resetShapeFlag(current); + } + cache.delete(key); + keys.delete(key); + } // prune cache on include/exclude prop change - function watchEffect(effect, options) { - return doWatch(effect, null, options); - } - function watchPostEffect(effect, options) { - return doWatch(effect, null, Object.assign(options || {}, { - flush: 'post' - })); - } + watch(() => [props.include, props.exclude], _ref9 => { + var [include, exclude] = _ref9; + include && pruneCache(name => matches(include, name)); + exclude && pruneCache(name => !matches(exclude, name)); + }, // prune post-render after `current` has been updated + { + flush: 'post', + deep: true + }); // cache sub tree after render - function watchSyncEffect(effect, options) { - return doWatch(effect, null, Object.assign(options || {}, { - flush: 'sync' - })); - } // initial value for watchers to trigger on undefined initial values + var pendingCacheKey = null; + var cacheSubtree = () => { + // fix #1621, the pendingCacheKey could be 0 + if (pendingCacheKey != null) { + cache.set(pendingCacheKey, getInnerChild(instance.subTree)); + } + }; - var INITIAL_WATCHER_VALUE = {}; // implementation + onMounted(cacheSubtree); + onUpdated(cacheSubtree); + onBeforeUnmount(() => { + cache.forEach(cached => { + var { + subTree, + suspense + } = instance; + var vnode = getInnerChild(subTree); + + if (cached.type === vnode.type) { + // current instance will be unmounted as part of keep-alive's unmount + resetShapeFlag(vnode); // but invoke its deactivated hook here + + var da = vnode.component.da; + da && queuePostRenderEffect(da, suspense); + return; + } - function watch(source, cb, options) { - if (!isFunction(cb)) { - warn$1("`watch(fn, options?)` signature has been moved to a separate API. " + "Use `watchEffect(fn, options?)` instead. `watch` now only " + "supports `watch(source, cb, options?) signature."); - } + unmount(cached); + }); + }); + return () => { + pendingCacheKey = null; - return doWatch(source, cb, options); - } + if (!slots.default) { + return null; + } - function doWatch(source, cb) { - var { - immediate, - deep, - flush, - onTrack, - onTrigger - } = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : EMPTY_OBJ; + var children = slots.default(); + var rawVNode = children[0]; - if (!cb) { - if (immediate !== undefined) { - warn$1("watch() \"immediate\" option is only respected when using the " + "watch(source, callback, options?) signature."); - } + if (children.length > 1) { + { + warn("KeepAlive should contain exactly one component child."); + } + current = null; + return children; + } else if (!isVNode(rawVNode) || !(rawVNode.shapeFlag & 4 + /* STATEFUL_COMPONENT */ + ) && !(rawVNode.shapeFlag & 128 + /* SUSPENSE */ + )) { + current = null; + return rawVNode; + } - if (deep !== undefined) { - warn$1("watch() \"deep\" option is only respected when using the " + "watch(source, callback, options?) signature."); - } - } + var vnode = getInnerChild(rawVNode); + var comp = vnode.type; // for async components, name check should be based in its loaded + // inner component if available - var warnInvalidSource = s => { - warn$1("Invalid watch source: ", s, "A watch source can only be a getter/effect function, a ref, " + "a reactive object, or an array of these types."); - }; + var name = getComponentName(isAsyncWrapper(vnode) ? vnode.type.__asyncResolved || {} : comp); + var { + include, + exclude, + max + } = props; - var instance = currentInstance; - var getter; - var forceTrigger = false; - var isMultiSource = false; - - if (isRef(source)) { - getter = () => source.value; - - forceTrigger = isShallow(source); - } else if (isReactive(source)) { - getter = () => source; - - deep = true; - } else if (isArray(source)) { - isMultiSource = true; - forceTrigger = source.some(isReactive); - - getter = () => source.map(s => { - if (isRef(s)) { - return s.value; - } else if (isReactive(s)) { - return traverse(s); - } else if (isFunction(s)) { - return callWithErrorHandling(s, instance, 2 - /* WATCH_GETTER */ - ); - } else { - warnInvalidSource(s); - } - }); - } else if (isFunction(source)) { - if (cb) { - // getter with cb - getter = () => callWithErrorHandling(source, instance, 2 - /* WATCH_GETTER */ - ); - } else { - // no cb -> simple effect - getter = () => { - if (instance && instance.isUnmounted) { - return; + if (include && (!name || !matches(include, name)) || exclude && name && matches(exclude, name)) { + current = vnode; + return rawVNode; } - if (cleanup) { - cleanup(); - } + var key = vnode.key == null ? comp : vnode.key; + var cachedVNode = cache.get(key); // clone vnode if it's reused because we are going to mutate it - return callWithAsyncErrorHandling(source, instance, 3 - /* WATCH_CALLBACK */ - , [onCleanup]); - }; - } - } else { - getter = NOOP; - warnInvalidSource(source); - } + if (vnode.el) { + vnode = cloneVNode(vnode); - if (cb && deep) { - var baseGetter = getter; + if (rawVNode.shapeFlag & 128 + /* SUSPENSE */ + ) { + rawVNode.ssContent = vnode; + } + } // #1513 it's possible for the returned vnode to be cloned due to attr + // fallthrough or scopeId, so the vnode here may not be the final vnode + // that is mounted. Instead of caching it directly, we store the pending + // key and cache `instance.subTree` (the normalized vnode) in + // beforeMount/beforeUpdate hooks. - getter = () => traverse(baseGetter()); - } - var cleanup; + pendingCacheKey = key; - var onCleanup = fn => { - cleanup = effect.onStop = () => { - callWithErrorHandling(fn, instance, 4 - /* WATCH_CLEANUP */ - ); - }; - }; // in SSR there is no need to setup an actual effect, and it should be noop - // unless it's eager + if (cachedVNode) { + // copy over mounted state + vnode.el = cachedVNode.el; + vnode.component = cachedVNode.component; + if (vnode.transition) { + // recursively update transition hooks on subTree + setTransitionHooks(vnode, vnode.transition); + } // avoid vnode being mounted as fresh - if (isInSSRComponentSetup) { - // we will also not call the invalidate callback (+ runner is not set up) - onCleanup = NOOP; - if (!cb) { - getter(); - } else if (immediate) { - callWithAsyncErrorHandling(cb, instance, 3 - /* WATCH_CALLBACK */ - , [getter(), isMultiSource ? [] : undefined, onCleanup]); - } + vnode.shapeFlag |= 512 + /* COMPONENT_KEPT_ALIVE */ + ; // make this key the freshest - return NOOP; - } + keys.delete(key); + keys.add(key); + } else { + keys.add(key); // prune oldest entry + + if (max && keys.size > parseInt(max, 10)) { + pruneCacheEntry(keys.values().next().value); + } + } // avoid vnode being unmounted - var oldValue = isMultiSource ? [] : INITIAL_WATCHER_VALUE; - var job = () => { - if (!effect.active) { - return; + vnode.shapeFlag |= 256 + /* COMPONENT_SHOULD_KEEP_ALIVE */ + ; + current = vnode; + return rawVNode; + }; } - if (cb) { - // watch(source, cb) - var newValue = effect.run(); + }; // export the public type for h/tsx inference + // also to avoid inline import() in generated d.ts files - if (deep || forceTrigger || (isMultiSource ? newValue.some((v, i) => hasChanged(v, oldValue[i])) : hasChanged(newValue, oldValue)) || false) { - // cleanup before running cb again - if (cleanup) { - cleanup(); - } + var KeepAlive = KeepAliveImpl; - callWithAsyncErrorHandling(cb, instance, 3 - /* WATCH_CALLBACK */ - , [newValue, // pass undefined as the old value when it's changed for the first time - oldValue === INITIAL_WATCHER_VALUE ? undefined : oldValue, onCleanup]); - oldValue = newValue; - } - } else { - // watchEffect - effect.run(); + function matches(pattern, name) { + if (shared.isArray(pattern)) { + return pattern.some(p => matches(p, name)); + } else if (shared.isString(pattern)) { + return pattern.split(',').includes(name); + } else if (pattern.test) { + return pattern.test(name); } - }; // important: mark the job as a watcher callback so that scheduler knows - // it is allowed to self-trigger (#1727) + /* istanbul ignore next */ - job.allowRecurse = !!cb; - var scheduler; - - if (flush === 'sync') { - scheduler = job; // the scheduler function gets called directly - } else if (flush === 'post') { - scheduler = () => queuePostRenderEffect(job, instance && instance.suspense); - } else { - // default: 'pre' - scheduler = () => { - if (!instance || instance.isMounted) { - queuePreFlushCb(job); - } else { - // with 'pre' option, the first call must happen before - // the component is mounted so it is called synchronously. - job(); - } - }; + return false; } - var effect = new ReactiveEffect(getter, scheduler); - { - effect.onTrack = onTrack; - effect.onTrigger = onTrigger; - } // initial run - - if (cb) { - if (immediate) { - job(); - } else { - oldValue = effect.run(); - } - } else if (flush === 'post') { - queuePostRenderEffect(effect.run.bind(effect), instance && instance.suspense); - } else { - effect.run(); + function onActivated(hook, target) { + registerKeepAliveHook(hook, "a" + /* ACTIVATED */ + , target); } - return () => { - effect.stop(); + function onDeactivated(hook, target) { + registerKeepAliveHook(hook, "da" + /* DEACTIVATED */ + , target); + } - if (instance && instance.scope) { - remove(instance.scope.effects, effect); - } - }; - } // this.$watch + function registerKeepAliveHook(hook, type) { + var target = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 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". + var wrappedHook = hook.__wdc || (hook.__wdc = () => { + // only fire the hook if the target instance is NOT in a deactivated branch. + var current = target; - function instanceWatch(source, value, options) { - var publicThis = this.proxy; - var getter = isString(source) ? source.includes('.') ? createPathGetter(publicThis, source) : () => publicThis[source] : source.bind(publicThis, publicThis); - var cb; + while (current) { + if (current.isDeactivated) { + return; + } - if (isFunction(value)) { - cb = value; - } else { - cb = value.handler; - options = value; - } + current = current.parent; + } - var cur = currentInstance; - setCurrentInstance(this); - var res = doWatch(getter, cb.bind(publicThis), options); + return hook(); + }); - if (cur) { - setCurrentInstance(cur); - } else { - unsetCurrentInstance(); - } + 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. - return res; - } + if (target) { + var current = target.parent; - function createPathGetter(ctx, path) { - var segments = path.split('.'); - return () => { - var cur = ctx; + while (current && current.parent) { + if (isKeepAlive(current.parent.vnode)) { + injectToKeepAliveRoot(wrappedHook, type, target, current); + } - for (var i = 0; i < segments.length && cur; i++) { - cur = cur[segments[i]]; + current = current.parent; + } } - - return cur; - }; - } - - function traverse(value, seen) { - if (!isObject(value) || value["__v_skip" - /* SKIP */ - ]) { - return value; } - seen = seen || new Set(); - - if (seen.has(value)) { - return value; + function injectToKeepAliveRoot(hook, type, target, keepAliveRoot) { + // injectHook wraps the original for error handling, so make sure to remove + // the wrapped version. + var injected = injectHook(type, hook, keepAliveRoot, true + /* prepend */ + ); + onUnmounted(() => { + shared.remove(keepAliveRoot[type], injected); + }, target); } - seen.add(value); + function resetShapeFlag(vnode) { + var shapeFlag = vnode.shapeFlag; - if (isRef(value)) { - traverse(value.value, seen); - } else if (isArray(value)) { - for (var i = 0; i < value.length; i++) { - traverse(value[i], seen); - } - } else if (isSet(value) || isMap(value)) { - value.forEach(v => { - traverse(v, seen); - }); - } else if (isPlainObject(value)) { - for (var key in value) { - traverse(value[key], seen); + if (shapeFlag & 256 + /* COMPONENT_SHOULD_KEEP_ALIVE */ + ) { + shapeFlag -= 256 + /* COMPONENT_SHOULD_KEEP_ALIVE */ + ; } - } - - return value; - } - - function useTransitionState() { - var state = { - isMounted: false, - isLeaving: false, - isUnmounting: false, - leavingVNodes: new Map() - }; - onMounted(() => { - state.isMounted = true; - }); - onBeforeUnmount(() => { - state.isUnmounting = true; - }); - return state; - } - - var TransitionHookValidator = [Function, Array]; - var BaseTransitionImpl = { - name: "BaseTransition", - props: { - mode: String, - appear: Boolean, - persisted: Boolean, - // enter - onBeforeEnter: TransitionHookValidator, - onEnter: TransitionHookValidator, - onAfterEnter: TransitionHookValidator, - onEnterCancelled: TransitionHookValidator, - // leave - onBeforeLeave: TransitionHookValidator, - onLeave: TransitionHookValidator, - onAfterLeave: TransitionHookValidator, - onLeaveCancelled: TransitionHookValidator, - // appear - onBeforeAppear: TransitionHookValidator, - onAppear: TransitionHookValidator, - onAfterAppear: TransitionHookValidator, - onAppearCancelled: TransitionHookValidator - }, - - setup(props, _ref8) { - var { - slots - } = _ref8; - var instance = getCurrentInstance(); - var state = useTransitionState(); - var prevTransitionKey; - return () => { - var children = slots.default && getTransitionRawChildren(slots.default(), true); - - if (!children || !children.length) { - return; - } // warn multiple elements - - - if (children.length > 1) { - warn$1(' can only be used on a single element or component. Use ' + ' for lists.'); - } // there's no need to track reactivity for these props so use the raw - // props for a bit better perf - - var rawProps = toRaw(props); - var { - mode - } = rawProps; // check mode - - if (mode && mode !== 'in-out' && mode !== 'out-in' && mode !== 'default') { - warn$1("invalid mode: ".concat(mode)); - } // at this point children has a guaranteed length of 1. + if (shapeFlag & 512 + /* COMPONENT_KEPT_ALIVE */ + ) { + shapeFlag -= 512 + /* COMPONENT_KEPT_ALIVE */ + ; + } + vnode.shapeFlag = shapeFlag; + } - var child = children[0]; + function getInnerChild(vnode) { + return vnode.shapeFlag & 128 + /* SUSPENSE */ + ? vnode.ssContent : vnode; + } - if (state.isLeaving) { - return emptyPlaceholder(child); - } // in the case of , we need to - // compare the type of the kept-alive children. + function injectHook(type, hook) { + var target = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : currentInstance; + var prepend = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false; + if (target) { + var 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". - var innerChild = getKeepAliveChild(child); + var wrappedHook = hook.__weh || (hook.__weh = function () { + if (target.isUnmounted) { + return; + } // disable tracking inside all lifecycle hooks + // since they can potentially be called inside effects. - if (!innerChild) { - return emptyPlaceholder(child); - } - var enterHooks = resolveTransitionHooks(innerChild, rawProps, state, instance); - setTransitionHooks(innerChild, enterHooks); - var oldChild = instance.subTree; - var oldInnerChild = oldChild && getKeepAliveChild(oldChild); - var transitionKeyChanged = false; - var { - getTransitionKey - } = innerChild.type; + reactivity.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. - if (getTransitionKey) { - var key = getTransitionKey(); + setCurrentInstance(target); - if (prevTransitionKey === undefined) { - prevTransitionKey = key; - } else if (key !== prevTransitionKey) { - prevTransitionKey = key; - transitionKeyChanged = true; + for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) { + args[_key4] = arguments[_key4]; } - } // handle mode + var res = callWithAsyncErrorHandling(hook, target, type, args); + unsetCurrentInstance(); + reactivity.resetTracking(); + return res; + }); - if (oldInnerChild && oldInnerChild.type !== Comment && (!isSameVNodeType(innerChild, oldInnerChild) || transitionKeyChanged)) { - var leavingHooks = resolveTransitionHooks(oldInnerChild, rawProps, state, instance); // update old tree's hooks in case of dynamic transition + if (prepend) { + hooks.unshift(wrappedHook); + } else { + hooks.push(wrappedHook); + } - setTransitionHooks(oldInnerChild, leavingHooks); // switching between different views + return wrappedHook; + } else { + // fixed by xxxxxx + var apiName = shared.toHandlerKey((ErrorTypeStrings[type] || type.replace(/^on/, '')).replace(/ hook$/, '')); + warn("".concat(apiName, " is called when there is no active component instance to be ") + "associated with. " + "Lifecycle injection APIs can only be used during execution of setup()." + (" If you are using async setup(), make sure to register lifecycle " + "hooks before the first await statement.")); + } + } - if (mode === 'out-in') { - state.isLeaving = true; // return placeholder node and queue update when leave finishes + var createHook = lifecycle => function (hook) { + var target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : currentInstance; + return (// post-create lifecycle registrations are noops during SSR (except for serverPrefetch) + (!isInSSRComponentSetup || lifecycle === "sp" + /* SERVER_PREFETCH */ + ) && injectHook(lifecycle, hook, target) + ); + }; - leavingHooks.afterLeave = () => { - state.isLeaving = false; - instance.update(); - }; + var onBeforeMount = createHook("bm" + /* BEFORE_MOUNT */ + ); + var onMounted = createHook("m" + /* MOUNTED */ + ); + var onBeforeUpdate = createHook("bu" + /* BEFORE_UPDATE */ + ); + var onUpdated = createHook("u" + /* UPDATED */ + ); + var onBeforeUnmount = createHook("bum" + /* BEFORE_UNMOUNT */ + ); + var onUnmounted = createHook("um" + /* UNMOUNTED */ + ); + var onServerPrefetch = createHook("sp" + /* SERVER_PREFETCH */ + ); + var onRenderTriggered = createHook("rtg" + /* RENDER_TRIGGERED */ + ); + var onRenderTracked = createHook("rtc" + /* RENDER_TRACKED */ + ); - return emptyPlaceholder(child); - } else if (mode === 'in-out' && innerChild.type !== Comment) { - leavingHooks.delayLeave = (el, earlyRemove, delayedLeave) => { - var leavingVNodesCache = getLeavingNodesForType(state, oldInnerChild); - leavingVNodesCache[String(oldInnerChild.key)] = oldInnerChild; // early removal callback - - el._leaveCb = () => { - earlyRemove(); - el._leaveCb = undefined; - delete enterHooks.delayedLeave; - }; + function onErrorCaptured(hook) { + var target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : currentInstance; + injectHook("ec" + /* ERROR_CAPTURED */ + , hook, target); + } - enterHooks.delayedLeave = delayedLeave; - }; - } + function createDuplicateChecker() { + var cache = Object.create(null); + return (type, key) => { + if (cache[key]) { + warn("".concat(type, " property \"").concat(key, "\" is already defined in ").concat(cache[key], ".")); + } else { + cache[key] = type; } - - return child; }; } - }; // export the public type for h/tsx inference - // also to avoid inline import() in generated d.ts files - - var BaseTransition = BaseTransitionImpl; - - function getLeavingNodesForType(state, vnode) { - var { - leavingVNodes - } = state; - var leavingVNodesCache = leavingVNodes.get(vnode.type); - - if (!leavingVNodesCache) { - leavingVNodesCache = Object.create(null); - leavingVNodes.set(vnode.type, leavingVNodesCache); - } - - return leavingVNodesCache; - } // The transition hooks are attached to the vnode as vnode.transition - // and will be called at appropriate timing in the renderer. - - - function resolveTransitionHooks(vnode, props, state, instance) { - var { - appear, - mode, - persisted = false, - onBeforeEnter, - onEnter, - onAfterEnter, - onEnterCancelled, - onBeforeLeave, - onLeave, - onAfterLeave, - onLeaveCancelled, - onBeforeAppear, - onAppear, - onAfterAppear, - onAppearCancelled - } = props; - var key = String(vnode.key); - var leavingVNodesCache = getLeavingNodesForType(state, vnode); - - var callHook = (hook, args) => { - hook && callWithAsyncErrorHandling(hook, instance, 9 - /* TRANSITION_HOOK */ - , args); - }; - - var hooks = { - mode, - persisted, + var shouldCacheAccess = true; - beforeEnter(el) { - var hook = onBeforeEnter; - - if (!state.isMounted) { - if (appear) { - hook = onBeforeAppear || onBeforeEnter; - } else { - return; - } - } // for same element (v-show) + function applyOptions(instance) { + var options = resolveMergedOptions(instance); + var publicThis = instance.proxy; + var ctx = instance.ctx; // do not cache property access on public proxy during state initialization + shouldCacheAccess = false; // call beforeCreate first before accessing other options since + // the hook may mutate resolved options (#2791) - if (el._leaveCb) { - el._leaveCb(true - /* cancelled */ - ); - } // for toggled element with same key (v-if) - + if (options.beforeCreate) { + callHook(options.beforeCreate, instance, "bc" + /* BEFORE_CREATE */ + ); + } - var leavingVNode = leavingVNodesCache[key]; + var { + // state + data: dataOptions, + computed: computedOptions, + methods, + watch: watchOptions, + provide: provideOptions, + inject: injectOptions, + // lifecycle + created, + beforeMount, + mounted, + beforeUpdate, + updated, + activated, + deactivated, + beforeDestroy, + beforeUnmount, + destroyed, + unmounted, + render, + renderTracked, + renderTriggered, + errorCaptured, + serverPrefetch, + // public API + expose, + inheritAttrs, + // assets + components, + directives, + filters + } = options; + var checkDuplicateProperties = createDuplicateChecker(); + { + var [propsOptions] = instance.propsOptions; - if (leavingVNode && isSameVNodeType(vnode, leavingVNode) && leavingVNode.el._leaveCb) { - // force early removal (not cancelled) - leavingVNode.el._leaveCb(); + if (propsOptions) { + for (var key in propsOptions) { + checkDuplicateProperties("Props" + /* PROPS */ + , key); + } } + } // options initialization order (to be consistent with Vue 2): + // - props (already done outside of this function) + // - inject + // - methods + // - data (deferred since it relies on `this` access) + // - computed + // - watch (deferred since it relies on `this` access) - callHook(hook, [el]); - }, + if (injectOptions) { + resolveInjections(injectOptions, ctx, checkDuplicateProperties, instance.appContext.config.unwrapInjectedRef); + } - enter(el) { - var hook = onEnter; - var afterHook = onAfterEnter; - var cancelHook = onEnterCancelled; + if (methods) { + for (var _key5 in methods) { + var methodHandler = methods[_key5]; - if (!state.isMounted) { - if (appear) { - hook = onAppear || onEnter; - afterHook = onAfterAppear || onAfterEnter; - cancelHook = onAppearCancelled || onEnterCancelled; + if (shared.isFunction(methodHandler)) { + // In dev mode, we use the `createRenderContext` function to define + // methods to the proxy target, and those are read-only but + // reconfigurable, so it needs to be redefined here + { + Object.defineProperty(ctx, _key5, { + value: methodHandler.bind(publicThis), + configurable: true, + enumerable: true, + writable: true + }); + } + { + checkDuplicateProperties("Methods" + /* METHODS */ + , _key5); + } } else { - return; + warn("Method \"".concat(_key5, "\" has type \"").concat(typeof methodHandler, "\" in the component definition. ") + "Did you reference the function correctly?"); } } + } - var called = false; + if (dataOptions) { + (function () { + if (!shared.isFunction(dataOptions)) { + warn("The data option must be a function. " + "Plain object usage is no longer supported."); + } - var done = el._enterCb = cancelled => { - if (called) return; - called = true; + var data = dataOptions.call(publicThis, publicThis); - if (cancelled) { - callHook(cancelHook, [el]); - } else { - callHook(afterHook, [el]); + if (shared.isPromise(data)) { + warn("data() returned a Promise - note data() cannot be async; If you " + "intend to perform data fetching before component renders, use " + "async setup() + ."); } - if (hooks.delayedLeave) { - hooks.delayedLeave(); + if (!shared.isObject(data)) { + warn("data() should return an object."); + } else { + instance.data = reactivity.reactive(data); + { + var _loop = function (_key6) { + checkDuplicateProperties("Data" + /* DATA */ + , _key6); // expose data on ctx during dev + + if (_key6[0] !== '$' && _key6[0] !== '_') { + Object.defineProperty(ctx, _key6, { + configurable: true, + enumerable: true, + get: () => data[_key6], + set: shared.NOOP + }); + } + }; + + for (var _key6 in data) { + _loop(_key6); + } + } } + })(); + } // state initialization complete at this point - start caching access - el._enterCb = undefined; - }; - if (hook) { - hook(el, done); + shouldCacheAccess = true; - if (hook.length <= 1) { - done(); - } - } else { - done(); - } - }, + if (computedOptions) { + var _loop2 = function (_key7) { + var opt = computedOptions[_key7]; + var get = shared.isFunction(opt) ? opt.bind(publicThis, publicThis) : shared.isFunction(opt.get) ? opt.get.bind(publicThis, publicThis) : shared.NOOP; - leave(el, remove) { - var key = String(vnode.key); + if (get === shared.NOOP) { + warn("Computed property \"".concat(_key7, "\" has no getter.")); + } - if (el._enterCb) { - el._enterCb(true - /* cancelled */ - ); - } - - if (state.isUnmounting) { - return remove(); - } - - callHook(onBeforeLeave, [el]); - var called = false; - - var done = el._leaveCb = cancelled => { - if (called) return; - called = true; - remove(); - - if (cancelled) { - callHook(onLeaveCancelled, [el]); - } else { - callHook(onAfterLeave, [el]); - } - - el._leaveCb = undefined; - - if (leavingVNodesCache[key] === vnode) { - delete leavingVNodesCache[key]; + var set = !shared.isFunction(opt) && shared.isFunction(opt.set) ? opt.set.bind(publicThis) : () => { + warn("Write operation failed: computed property \"".concat(_key7, "\" is readonly.")); + }; + var c = computed({ + get, + set + }); + Object.defineProperty(ctx, _key7, { + enumerable: true, + configurable: true, + get: () => c.value, + set: v => c.value = v + }); + { + checkDuplicateProperties("Computed" + /* COMPUTED */ + , _key7); } }; - leavingVNodesCache[key] = vnode; - - if (onLeave) { - onLeave(el, done); - - if (onLeave.length <= 1) { - done(); - } - } else { - done(); + for (var _key7 in computedOptions) { + _loop2(_key7); } - }, + } - clone(vnode) { - return resolveTransitionHooks(vnode, props, state, instance); + if (watchOptions) { + for (var _key8 in watchOptions) { + createWatcher(watchOptions[_key8], ctx, publicThis, _key8); + } } - }; - return hooks; - } // the placeholder really only handles one special case: KeepAlive - // in the case of a KeepAlive in a leave phase we need to return a KeepAlive - // placeholder with empty content to avoid the KeepAlive instance from being - // unmounted. + if (provideOptions) { + var provides = shared.isFunction(provideOptions) ? provideOptions.call(publicThis) : provideOptions; + Reflect.ownKeys(provides).forEach(key => { + provide(key, provides[key]); + }); + } + if (created) { + callHook(created, instance, "c" + /* CREATED */ + ); + } - function emptyPlaceholder(vnode) { - if (isKeepAlive(vnode)) { - vnode = cloneVNode(vnode); - vnode.children = null; - return vnode; - } - } + function registerLifecycleHook(register, hook) { + if (shared.isArray(hook)) { + hook.forEach(_hook => register(_hook.bind(publicThis))); + } else if (hook) { + register(hook.bind(publicThis)); + } + } + + registerLifecycleHook(onBeforeMount, beforeMount); + registerLifecycleHook(onMounted, mounted); + registerLifecycleHook(onBeforeUpdate, beforeUpdate); + registerLifecycleHook(onUpdated, updated); + registerLifecycleHook(onActivated, activated); + registerLifecycleHook(onDeactivated, deactivated); + registerLifecycleHook(onErrorCaptured, errorCaptured); + registerLifecycleHook(onRenderTracked, renderTracked); + registerLifecycleHook(onRenderTriggered, renderTriggered); + registerLifecycleHook(onBeforeUnmount, beforeUnmount); + registerLifecycleHook(onUnmounted, unmounted); + registerLifecycleHook(onServerPrefetch, serverPrefetch); + + if (shared.isArray(expose)) { + if (expose.length) { + var exposed = instance.exposed || (instance.exposed = {}); + expose.forEach(key => { + Object.defineProperty(exposed, key, { + get: () => publicThis[key], + set: val => publicThis[key] = val + }); + }); + } else if (!instance.exposed) { + instance.exposed = {}; + } + } // options that are handled when creating the instance but also need to be + // applied from mixins - function getKeepAliveChild(vnode) { - return isKeepAlive(vnode) ? vnode.children ? vnode.children[0] : undefined : vnode; - } - function setTransitionHooks(vnode, hooks) { - if (vnode.shapeFlag & 6 - /* COMPONENT */ - && vnode.component) { - setTransitionHooks(vnode.component.subTree, hooks); - } else if (vnode.shapeFlag & 128 - /* SUSPENSE */ - ) { - vnode.ssContent.transition = hooks.clone(vnode.ssContent); - vnode.ssFallback.transition = hooks.clone(vnode.ssFallback); - } else { - vnode.transition = hooks; - } - } - - function getTransitionRawChildren(children) { - var keepComment = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; - var ret = []; - var keyedFragmentCount = 0; - - for (var i = 0; i < children.length; i++) { - var child = children[i]; // handle fragment children case, e.g. v-for - - if (child.type === Fragment) { - if (child.patchFlag & 128 - /* KEYED_FRAGMENT */ - ) keyedFragmentCount++; - ret = ret.concat(getTransitionRawChildren(child.children, keepComment)); - } // comment placeholders should be skipped, e.g. v-if - else if (keepComment || child.type !== Comment) { - ret.push(child); - } - } // #1126 if a transition children list contains multiple sub fragments, these - // fragments will be merged into a flat children array. Since each v-for - // fragment may contain different static bindings inside, we need to de-op - // these children to force full diffs to ensure correct behavior. - - - if (keyedFragmentCount > 1) { - for (var _i = 0; _i < ret.length; _i++) { - ret[_i].patchFlag = -2 - /* BAIL */ - ; + if (render && instance.render === shared.NOOP) { + instance.render = render; } - } - - return ret; - } // implementation, close to no-op - - function defineComponent(options) { - return isFunction(options) ? { - setup: options, - name: options.name - } : options; - } + if (inheritAttrs != null) { + instance.inheritAttrs = inheritAttrs; + } // asset options. - var isAsyncWrapper = i => !!i.type.__asyncLoader; - function defineAsyncComponent(source) { - if (isFunction(source)) { - source = { - loader: source - }; + if (components) instance.components = components; + if (directives) instance.directives = directives; } - var { - loader, - loadingComponent, - errorComponent, - delay = 200, - timeout, - // undefined = never times out - suspensible = true, - onError: userOnError - } = source; - var pendingRequest = null; - var resolvedComp; - var retries = 0; - - var retry = () => { - retries++; - pendingRequest = null; - return load(); - }; - - var load = () => { - var thisRequest; - return pendingRequest || (thisRequest = pendingRequest = loader().catch(err => { - err = err instanceof Error ? err : new Error(String(err)); + function resolveInjections(injectOptions, ctx) { + var checkDuplicateProperties = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : shared.NOOP; + var unwrapRef = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false; - if (userOnError) { - return new Promise((resolve, reject) => { - var userRetry = () => resolve(retry()); + if (shared.isArray(injectOptions)) { + injectOptions = normalizeInject(injectOptions); + } - var userFail = () => reject(err); + var _loop3 = function (key) { + var opt = injectOptions[key]; + var injected = void 0; - userOnError(err, userRetry, userFail, retries + 1); - }); + if (shared.isObject(opt)) { + if ('default' in opt) { + injected = inject(opt.from || key, opt.default, true + /* treat default function as factory */ + ); + } else { + injected = inject(opt.from || key); + } } else { - throw err; - } - }).then(comp => { - if (thisRequest !== pendingRequest && pendingRequest) { - return pendingRequest; + injected = inject(opt); } - if (!comp) { - warn$1("Async component loader resolved to undefined. " + "If you are using retry(), make sure to return its return value."); - } // interop module default - - - if (comp && (comp.__esModule || comp[Symbol.toStringTag] === 'Module')) { - comp = comp.default; + if (reactivity.isRef(injected)) { + // TODO remove the check in 3.3 + if (unwrapRef) { + Object.defineProperty(ctx, key, { + enumerable: true, + configurable: true, + get: () => injected.value, + set: v => injected.value = v + }); + } else { + { + warn("injected property \"".concat(key, "\" is a ref and will be auto-unwrapped ") + "and no longer needs `.value` in the next minor release. " + "To opt-in to the new behavior now, " + "set `app.config.unwrapInjectedRef = true` (this config is " + "temporary and will not be needed in the future.)"); + } + ctx[key] = injected; + } + } else { + ctx[key] = injected; } - if (comp && !isObject(comp) && !isFunction(comp)) { - throw new Error("Invalid async component load result: ".concat(comp)); + { + checkDuplicateProperties("Inject" + /* INJECT */ + , key); } + }; - resolvedComp = comp; - return comp; - })); - }; + for (var key in injectOptions) { + _loop3(key); + } + } - return defineComponent({ - name: 'AsyncComponentWrapper', - __asyncLoader: load, + function callHook(hook, instance, type) { + callWithAsyncErrorHandling(shared.isArray(hook) ? hook.map(h => h.bind(instance.proxy)) : hook.bind(instance.proxy), instance, type); + } - get __asyncResolved() { - return resolvedComp; - }, + function createWatcher(raw, ctx, publicThis, key) { + var getter = key.includes('.') ? createPathGetter(publicThis, key) : () => publicThis[key]; - setup() { - var instance = currentInstance; // already resolved + if (shared.isString(raw)) { + var handler = ctx[raw]; - if (resolvedComp) { - return () => createInnerComp(resolvedComp, instance); + if (shared.isFunction(handler)) { + watch(getter, handler); + } else { + warn("Invalid watch handler specified by key \"".concat(raw, "\""), handler); } + } else if (shared.isFunction(raw)) { + watch(getter, raw.bind(publicThis)); + } else if (shared.isObject(raw)) { + if (shared.isArray(raw)) { + raw.forEach(r => createWatcher(r, ctx, publicThis, key)); + } else { + var _handler = shared.isFunction(raw.handler) ? raw.handler.bind(publicThis) : ctx[raw.handler]; - var onError = err => { - pendingRequest = null; - handleError(err, instance, 13 - /* ASYNC_COMPONENT_LOADER */ - , !errorComponent - /* do not throw in dev if user provided error component */ - ); - }; // suspense-controlled or SSR. - - - if (suspensible && instance.suspense || isInSSRComponentSetup) { - return load().then(comp => { - return () => createInnerComp(comp, instance); - }).catch(err => { - onError(err); - return () => errorComponent ? createVNode(errorComponent, { - error: err - }) : null; - }); + if (shared.isFunction(_handler)) { + watch(getter, _handler, raw); + } else { + warn("Invalid watch handler specified by key \"".concat(raw.handler, "\""), _handler); + } } + } else { + warn("Invalid watch option: \"".concat(key, "\""), raw); + } + } + /** + * Resolve merged options and cache it on the component. + * This is done only once per-component since the merging does not involve + * instances. + */ - var loaded = ref(false); - var error = ref(); - var delayed = ref(!!delay); - if (delay) { - setTimeout(() => { - delayed.value = false; - }, delay); + function resolveMergedOptions(instance) { + var base = instance.type; + var { + mixins, + extends: extendsOptions + } = base; + var { + mixins: globalMixins, + optionsCache: cache, + config: { + optionMergeStrategies + } + } = instance.appContext; + var cached = cache.get(base); + var resolved; + + if (cached) { + resolved = cached; + } else if (!globalMixins.length && !mixins && !extendsOptions) { + { + resolved = base; } + } else { + resolved = {}; - if (timeout != null) { - setTimeout(() => { - if (!loaded.value && !error.value) { - var err = new Error("Async component timed out after ".concat(timeout, "ms.")); - onError(err); - error.value = err; - } - }, timeout); + if (globalMixins.length) { + globalMixins.forEach(m => mergeOptions(resolved, m, optionMergeStrategies, true)); } - load().then(() => { - loaded.value = true; - - if (instance.parent && isKeepAlive(instance.parent.vnode)) { - // parent is keep-alive, force update so the loaded component's - // name is taken into account - queueJob(instance.parent.update); - } - }).catch(err => { - onError(err); - error.value = err; - }); - return () => { - if (loaded.value && resolvedComp) { - return createInnerComp(resolvedComp, instance); - } else if (error.value && errorComponent) { - return createVNode(errorComponent, { - error: error.value - }); - } else if (loadingComponent && !delayed.value) { - return createVNode(loadingComponent); - } - }; + mergeOptions(resolved, base, optionMergeStrategies); } - }); - } + cache.set(base, resolved); + return resolved; + } - function createInnerComp(comp, _ref9) { - var { - vnode: { - ref, - props, - children - } - } = _ref9; - var vnode = createVNode(comp, props, children); // ensure inner component inherits the async wrapper's ref owner + function mergeOptions(to, from, strats) { + var asMixin = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false; + var { + mixins, + extends: extendsOptions + } = from; - vnode.ref = ref; - return vnode; - } + if (extendsOptions) { + mergeOptions(to, extendsOptions, strats, true); + } - var isKeepAlive = vnode => vnode.type.__isKeepAlive; + if (mixins) { + mixins.forEach(m => mergeOptions(to, m, strats, true)); + } - var KeepAliveImpl = { - name: "KeepAlive", - // Marker for special handling inside the renderer. We are not using a === - // check directly on KeepAlive in the renderer, because importing it directly - // would prevent it from being tree-shaken. - __isKeepAlive: true, - props: { - include: [String, RegExp, Array], - exclude: [String, RegExp, Array], - max: [String, Number] - }, + for (var key in from) { + if (asMixin && key === 'expose') { + warn("\"expose\" option is ignored when declared in mixins or extends. " + "It should only be declared in the base component itself."); + } else { + var strat = internalOptionMergeStrats[key] || strats && strats[key]; + to[key] = strat ? strat(to[key], from[key]) : from[key]; + } + } - setup(props, _ref10) { - var { - slots - } = _ref10; - var instance = getCurrentInstance(); // KeepAlive communicates with the instantiated renderer via the - // ctx where the renderer passes in its internals, - // and the KeepAlive instance exposes activate/deactivate implementations. - // The whole point of this is to avoid importing KeepAlive directly in the - // renderer to facilitate tree-shaking. + return to; + } - var sharedContext = instance.ctx; // if the internal renderer is not registered, it indicates that this is server-side rendering, - // for KeepAlive, we just need to render its children + var internalOptionMergeStrats = { + data: mergeDataFn, + props: mergeObjectOptions, + emits: mergeObjectOptions, + // objects + methods: mergeObjectOptions, + computed: mergeObjectOptions, + // lifecycle + beforeCreate: mergeAsArray, + created: mergeAsArray, + beforeMount: mergeAsArray, + mounted: mergeAsArray, + beforeUpdate: mergeAsArray, + updated: mergeAsArray, + beforeDestroy: mergeAsArray, + beforeUnmount: mergeAsArray, + destroyed: mergeAsArray, + unmounted: mergeAsArray, + activated: mergeAsArray, + deactivated: mergeAsArray, + errorCaptured: mergeAsArray, + serverPrefetch: mergeAsArray, + // assets + components: mergeObjectOptions, + directives: mergeObjectOptions, + // watch + watch: mergeWatchOptions, + // provide / inject + provide: mergeDataFn, + inject: mergeInject + }; - if (!sharedContext.renderer) { - return slots.default; + function mergeDataFn(to, from) { + if (!from) { + return to; } - var cache = new Map(); - var keys = new Set(); - var current = null; - { - instance.__v_cache = cache; + if (!to) { + return from; } - var parentSuspense = instance.suspense; - var { - renderer: { - p: patch, - m: move, - um: _unmount, - o: { - createElement - } - } - } = sharedContext; - var storageContainer = createElement('div'); - sharedContext.activate = (vnode, container, anchor, isSVG, optimized) => { - var instance = vnode.component; - move(vnode, container, anchor, 0 - /* ENTER */ - , parentSuspense); // in case props have changed - - patch(instance.vnode, vnode, container, anchor, instance, parentSuspense, isSVG, vnode.slotScopeIds, optimized); - queuePostRenderEffect(() => { - instance.isDeactivated = false; + return function mergedDataFn() { + return shared.extend(shared.isFunction(to) ? to.call(this, this) : to, shared.isFunction(from) ? from.call(this, this) : from); + }; + } - if (instance.a) { - invokeArrayFns(instance.a); - } + function mergeInject(to, from) { + return mergeObjectOptions(normalizeInject(to), normalizeInject(from)); + } - var vnodeHook = vnode.props && vnode.props.onVnodeMounted; + function normalizeInject(raw) { + if (shared.isArray(raw)) { + var res = {}; - if (vnodeHook) { - invokeVNodeHook(vnodeHook, instance.parent, vnode); - } - }, parentSuspense); - { - // Update components tree - devtoolsComponentAdded(instance); + for (var i = 0; i < raw.length; i++) { + res[raw[i]] = raw[i]; } - }; - sharedContext.deactivate = vnode => { - var instance = vnode.component; - move(vnode, storageContainer, null, 1 - /* LEAVE */ - , parentSuspense); - queuePostRenderEffect(() => { - if (instance.da) { - invokeArrayFns(instance.da); - } + return res; + } - var vnodeHook = vnode.props && vnode.props.onVnodeUnmounted; + return raw; + } - if (vnodeHook) { - invokeVNodeHook(vnodeHook, instance.parent, vnode); - } + function mergeAsArray(to, from) { + return to ? [...new Set([].concat(to, from))] : from; + } - instance.isDeactivated = true; - }, parentSuspense); - { - // Update components tree - devtoolsComponentAdded(instance); - } - }; + function mergeObjectOptions(to, from) { + return to ? shared.extend(shared.extend(Object.create(null), to), from) : from; + } - function unmount(vnode) { - // reset the shapeFlag so it can be properly unmounted - resetShapeFlag(vnode); + function mergeWatchOptions(to, from) { + if (!to) return from; + if (!from) return to; + var merged = shared.extend(Object.create(null), to); - _unmount(vnode, instance, parentSuspense, true); + for (var key in from) { + merged[key] = mergeAsArray(to[key], from[key]); } - function pruneCache(filter) { - cache.forEach((vnode, key) => { - var name = getComponentName(vnode.type); - - if (name && (!filter || !filter(name))) { - pruneCacheEntry(key); - } - }); - } + return merged; + } - function pruneCacheEntry(key) { - var cached = cache.get(key); + function initProps(instance, rawProps, isStateful) { + var isSSR = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false; + var props = {}; + var attrs = {}; + shared.def(attrs, InternalObjectKey, 1); + instance.propsDefaults = Object.create(null); + setFullProps(instance, rawProps, props, attrs); // ensure all declared prop keys are present - if (!current || cached.type !== current.type) { - unmount(cached); - } else if (current) { - // current active instance should no longer be kept-alive. - // we can't unmount it now but it might be later, so reset its flag now. - resetShapeFlag(current); + for (var key in instance.propsOptions[0]) { + if (!(key in props)) { + props[key] = undefined; } - - cache.delete(key); - keys.delete(key); - } // prune cache on include/exclude prop change + } // validation - watch(() => [props.include, props.exclude], _ref11 => { - var [include, exclude] = _ref11; - include && pruneCache(name => matches(include, name)); - exclude && pruneCache(name => !matches(exclude, name)); - }, // prune post-render after `current` has been updated { - flush: 'post', - deep: true - }); // cache sub tree after render - - var pendingCacheKey = null; + validateProps(rawProps || {}, props, instance); + } - var cacheSubtree = () => { - // fix #1621, the pendingCacheKey could be 0 - if (pendingCacheKey != null) { - cache.set(pendingCacheKey, getInnerChild(instance.subTree)); + if (isStateful) { + // stateful + instance.props = isSSR ? props : reactivity.shallowReactive(props); + } else { + if (!instance.type.props) { + // functional w/ optional props, props === attrs + instance.props = attrs; + } else { + // functional w/ declared props + instance.props = props; } - }; - - onMounted(cacheSubtree); - onUpdated(cacheSubtree); - onBeforeUnmount(() => { - cache.forEach(cached => { - var { - subTree, - suspense - } = instance; - var vnode = getInnerChild(subTree); + } - if (cached.type === vnode.type) { - // current instance will be unmounted as part of keep-alive's unmount - resetShapeFlag(vnode); // but invoke its deactivated hook here + instance.attrs = attrs; + } - var da = vnode.component.da; - da && queuePostRenderEffect(da, suspense); - return; + function updateProps(instance, rawProps, rawPrevProps, optimized) { + var { + props, + attrs, + vnode: { + patchFlag + } + } = instance; + var rawCurrentProps = reactivity.toRaw(props); + var [options] = instance.propsOptions; + var hasAttrsChanged = false; + + if ( // always force full diff in dev + // - #1942 if hmr is enabled with sfc component + // - vite#872 non-sfc component used by sfc component + !(instance.type.__hmrId || instance.parent && instance.parent.type.__hmrId) && (optimized || patchFlag > 0) && !(patchFlag & 16 + /* FULL_PROPS */ + )) { + if (patchFlag & 8 + /* PROPS */ + ) { + // Compiler-generated props & no keys change, just set the updated + // the props. + var propsToUpdate = instance.vnode.dynamicProps; + + for (var i = 0; i < propsToUpdate.length; i++) { + var key = propsToUpdate[i]; // PROPS flag guarantees rawProps to be non-null + + var 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 (shared.hasOwn(attrs, key)) { + if (value !== attrs[key]) { + attrs[key] = value; + hasAttrsChanged = true; + } + } else { + var camelizedKey = shared.camelize(key); + props[camelizedKey] = resolvePropValue(options, rawCurrentProps, camelizedKey, value, instance, false + /* isAbsent */ + ); + } + } else { + if (value !== attrs[key]) { + attrs[key] = value; + hasAttrsChanged = true; + } + } } - - unmount(cached); - }); - }); - return () => { - pendingCacheKey = null; - - if (!slots.default) { - return null; } + } else { + // full props update. + if (setFullProps(instance, rawProps, props, attrs)) { + hasAttrsChanged = true; + } // in case of dynamic props, check if we need to delete keys from + // the props object + + + var kebabKey; + + for (var _key9 in rawCurrentProps) { + if (!rawProps || // for camelCase + !shared.hasOwn(rawProps, _key9) && ( // it's possible the original props was passed in as kebab-case + // and converted to camelCase (#955) + (kebabKey = shared.hyphenate(_key9)) === _key9 || !shared.hasOwn(rawProps, kebabKey))) { + if (options) { + if (rawPrevProps && ( // for camelCase + rawPrevProps[_key9] !== undefined || // for kebab-case + rawPrevProps[kebabKey] !== undefined)) { + props[_key9] = resolvePropValue(options, rawCurrentProps, _key9, undefined, instance, true + /* isAbsent */ + ); + } + } else { + delete props[_key9]; + } + } + } // 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. - var children = slots.default(); - var rawVNode = children[0]; - if (children.length > 1) { - { - warn$1("KeepAlive should contain exactly one component child."); + if (attrs !== rawCurrentProps) { + for (var _key10 in attrs) { + if (!rawProps || !shared.hasOwn(rawProps, _key10) && !false) { + delete attrs[_key10]; + hasAttrsChanged = true; + } } - current = null; - return children; - } else if (!isVNode(rawVNode) || !(rawVNode.shapeFlag & 4 - /* STATEFUL_COMPONENT */ - ) && !(rawVNode.shapeFlag & 128 - /* SUSPENSE */ - )) { - current = null; - return rawVNode; } + } // trigger updates for $attrs in case it's used in component slots - var vnode = getInnerChild(rawVNode); - var comp = vnode.type; // for async components, name check should be based in its loaded - // inner component if available - - var name = getComponentName(isAsyncWrapper(vnode) ? vnode.type.__asyncResolved || {} : comp); - var { - include, - exclude, - max - } = props; - if (include && (!name || !matches(include, name)) || exclude && name && matches(exclude, name)) { - current = vnode; - return rawVNode; - } + if (hasAttrsChanged) { + reactivity.trigger(instance, "set" + /* SET */ + , '$attrs'); + } - var key = vnode.key == null ? comp : vnode.key; - var cachedVNode = cache.get(key); // clone vnode if it's reused because we are going to mutate it + { + validateProps(rawProps || {}, props, instance); + } + } - if (vnode.el) { - vnode = cloneVNode(vnode); + function setFullProps(instance, rawProps, props, attrs) { + var [options, needCastKeys] = instance.propsOptions; + var hasAttrsChanged = false; + var rawCastValues; - if (rawVNode.shapeFlag & 128 - /* SUSPENSE */ - ) { - rawVNode.ssContent = vnode; + if (rawProps) { + for (var key in rawProps) { + // key, ref are reserved and never passed down + if (shared.isReservedProp(key)) { + continue; } - } // #1513 it's possible for the returned vnode to be cloned due to attr - // fallthrough or scopeId, so the vnode here may not be the final vnode - // that is mounted. Instead of caching it directly, we store the pending - // key and cache `instance.subTree` (the normalized vnode) in - // beforeMount/beforeUpdate hooks. + var value = rawProps[key]; // prop option names are camelized during normalization, so to support + // kebab -> camel conversion here we need to camelize the key. - pendingCacheKey = key; + var camelKey = void 0; - if (cachedVNode) { - // copy over mounted state - vnode.el = cachedVNode.el; - vnode.component = cachedVNode.component; + if (options && shared.hasOwn(options, camelKey = shared.camelize(key))) { + if (!needCastKeys || !needCastKeys.includes(camelKey)) { + props[camelKey] = value; + } else { + (rawCastValues || (rawCastValues = {}))[camelKey] = value; + } + } else if (!isEmitListener(instance.emitsOptions, key)) { + if (!(key in attrs) || value !== attrs[key]) { + attrs[key] = value; + hasAttrsChanged = true; + } + } + } + } - if (vnode.transition) { - // recursively update transition hooks on subTree - setTransitionHooks(vnode, vnode.transition); - } // avoid vnode being mounted as fresh + if (needCastKeys) { + var rawCurrentProps = reactivity.toRaw(props); + var castValues = rawCastValues || shared.EMPTY_OBJ; + for (var i = 0; i < needCastKeys.length; i++) { + var _key11 = needCastKeys[i]; + props[_key11] = resolvePropValue(options, rawCurrentProps, _key11, castValues[_key11], instance, !shared.hasOwn(castValues, _key11)); + } + } - vnode.shapeFlag |= 512 - /* COMPONENT_KEPT_ALIVE */ - ; // make this key the freshest + return hasAttrsChanged; + } - keys.delete(key); - keys.add(key); - } else { - keys.add(key); // prune oldest entry + function resolvePropValue(options, props, key, value, instance, isAbsent) { + var opt = options[key]; - if (max && keys.size > parseInt(max, 10)) { - pruneCacheEntry(keys.values().next().value); - } - } // avoid vnode being unmounted + if (opt != null) { + var hasDefault = shared.hasOwn(opt, 'default'); // default values + if (hasDefault && value === undefined) { + var defaultValue = opt.default; - vnode.shapeFlag |= 256 - /* COMPONENT_SHOULD_KEEP_ALIVE */ - ; - current = vnode; - return rawVNode; - }; - } + if (opt.type !== Function && shared.isFunction(defaultValue)) { + var { + propsDefaults + } = instance; + + if (key in propsDefaults) { + value = propsDefaults[key]; + } else { + setCurrentInstance(instance); + value = propsDefaults[key] = defaultValue.call(null, props); + unsetCurrentInstance(); + } + } else { + value = defaultValue; + } + } // boolean casting - }; // export the public type for h/tsx inference - // also to avoid inline import() in generated d.ts files - var KeepAlive = KeepAliveImpl; + if (opt[0 + /* shouldCast */ + ]) { + if (isAbsent && !hasDefault) { + value = false; + } else if (opt[1 + /* shouldCastTrue */ + ] && (value === '' || value === shared.hyphenate(key))) { + value = true; + } + } + } - function matches(pattern, name) { - if (isArray(pattern)) { - return pattern.some(p => matches(p, name)); - } else if (isString(pattern)) { - return pattern.split(',').includes(name); - } else if (pattern.test) { - return pattern.test(name); + return value; } - /* istanbul ignore next */ + function normalizePropsOptions(comp, appContext) { + var asMixin = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; + var cache = appContext.propsCache; + var cached = cache.get(comp); - return false; - } + if (cached) { + return cached; + } - function onActivated(hook, target) { - registerKeepAliveHook(hook, "a" - /* ACTIVATED */ - , target); - } + var raw = comp.props; + var normalized = {}; + var needCastKeys = []; // apply mixin/extends props - function onDeactivated(hook, target) { - registerKeepAliveHook(hook, "da" - /* DEACTIVATED */ - , target); - } + var hasExtends = false; - function registerKeepAliveHook(hook, type) { - var target = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : currentInstance; + if (!shared.isFunction(comp)) { + var extendProps = raw => { + hasExtends = true; + var [props, keys] = normalizePropsOptions(raw, appContext, true); + shared.extend(normalized, props); + if (keys) needCastKeys.push(...keys); + }; - // 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". - var wrappedHook = hook.__wdc || (hook.__wdc = () => { - // only fire the hook if the target instance is NOT in a deactivated branch. - var current = target; + if (!asMixin && appContext.mixins.length) { + appContext.mixins.forEach(extendProps); + } - while (current) { - if (current.isDeactivated) { - return; + if (comp.extends) { + extendProps(comp.extends); } - current = current.parent; + if (comp.mixins) { + comp.mixins.forEach(extendProps); + } } - return hook(); - }); + if (!raw && !hasExtends) { + cache.set(comp, shared.EMPTY_ARR); + return shared.EMPTY_ARR; + } - 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 (shared.isArray(raw)) { + for (var i = 0; i < raw.length; i++) { + if (!shared.isString(raw[i])) { + warn("props must be strings when using array syntax.", raw[i]); + } - if (target) { - var current = target.parent; + var normalizedKey = shared.camelize(raw[i]); - while (current && current.parent) { - if (isKeepAlive(current.parent.vnode)) { - injectToKeepAliveRoot(wrappedHook, type, target, current); + if (validatePropName(normalizedKey)) { + normalized[normalizedKey] = shared.EMPTY_OBJ; + } + } + } else if (raw) { + if (!shared.isObject(raw)) { + warn("invalid props options", raw); } - current = current.parent; - } - } - } + for (var key in raw) { + var _normalizedKey = shared.camelize(key); - function injectToKeepAliveRoot(hook, type, target, keepAliveRoot) { - // injectHook wraps the original for error handling, so make sure to remove - // the wrapped version. - var injected = injectHook(type, hook, keepAliveRoot, true - /* prepend */ - ); - onUnmounted(() => { - remove(keepAliveRoot[type], injected); - }, target); - } + if (validatePropName(_normalizedKey)) { + var opt = raw[key]; + var prop = normalized[_normalizedKey] = shared.isArray(opt) || shared.isFunction(opt) ? { + type: opt + } : opt; - function resetShapeFlag(vnode) { - var shapeFlag = vnode.shapeFlag; + if (prop) { + var booleanIndex = getTypeIndex(Boolean, prop.type); + var 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 (shapeFlag & 256 - /* COMPONENT_SHOULD_KEEP_ALIVE */ - ) { - shapeFlag -= 256 - /* COMPONENT_SHOULD_KEEP_ALIVE */ - ; - } - - if (shapeFlag & 512 - /* COMPONENT_KEPT_ALIVE */ - ) { - shapeFlag -= 512 - /* COMPONENT_KEPT_ALIVE */ - ; - } - - vnode.shapeFlag = shapeFlag; - } - - function getInnerChild(vnode) { - return vnode.shapeFlag & 128 - /* SUSPENSE */ - ? vnode.ssContent : vnode; - } - - function injectHook(type, hook) { - var target = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : currentInstance; - var prepend = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false; - - if (target) { - var 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". - - var wrappedHook = hook.__weh || (hook.__weh = function () { - 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); - - for (var _len7 = arguments.length, args = new Array(_len7), _key8 = 0; _key8 < _len7; _key8++) { - args[_key8] = arguments[_key8]; + if (booleanIndex > -1 || shared.hasOwn(prop, 'default')) { + needCastKeys.push(_normalizedKey); + } + } + } } - - var res = callWithAsyncErrorHandling(hook, target, type, args); - unsetCurrentInstance(); - resetTracking(); - return res; - }); - - if (prepend) { - hooks.unshift(wrappedHook); - } else { - hooks.push(wrappedHook); } - return wrappedHook; - } else { - // fixed by xxxxxx - var apiName = toHandlerKey((ErrorTypeStrings[type] || type.replace(/^on/, '')).replace(/ hook$/, '')); - warn$1("".concat(apiName, " is called when there is no active component instance to be ") + "associated with. " + "Lifecycle injection APIs can only be used during execution of setup()." + (" If you are using async setup(), make sure to register lifecycle " + "hooks before the first await statement.")); + var res = [normalized, needCastKeys]; + cache.set(comp, res); + return res; } - } - var createHook = lifecycle => function (hook) { - var target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : currentInstance; - return (// post-create lifecycle registrations are noops during SSR (except for serverPrefetch) - (!isInSSRComponentSetup || lifecycle === "sp" - /* SERVER_PREFETCH */ - ) && injectHook(lifecycle, hook, target) - ); - }; - - var onBeforeMount = createHook("bm" - /* BEFORE_MOUNT */ - ); - var onMounted = createHook("m" - /* MOUNTED */ - ); - var onBeforeUpdate = createHook("bu" - /* BEFORE_UPDATE */ - ); - var onUpdated = createHook("u" - /* UPDATED */ - ); - var onBeforeUnmount = createHook("bum" - /* BEFORE_UNMOUNT */ - ); - var onUnmounted = createHook("um" - /* UNMOUNTED */ - ); - var onServerPrefetch = createHook("sp" - /* SERVER_PREFETCH */ - ); - var onRenderTriggered = createHook("rtg" - /* RENDER_TRIGGERED */ - ); - var onRenderTracked = createHook("rtc" - /* RENDER_TRACKED */ - ); - - function onErrorCaptured(hook) { - var target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : currentInstance; - injectHook("ec" - /* ERROR_CAPTURED */ - , hook, target); - } - - function createDuplicateChecker() { - var cache = Object.create(null); - return (type, key) => { - if (cache[key]) { - warn$1("".concat(type, " property \"").concat(key, "\" is already defined in ").concat(cache[key], ".")); + function validatePropName(key) { + if (key[0] !== '$') { + return true; } else { - cache[key] = type; + warn("Invalid prop name: \"".concat(key, "\" is a reserved property.")); } - }; - } - var shouldCacheAccess = true; - - function applyOptions(instance) { - var options = resolveMergedOptions(instance); - var publicThis = instance.proxy; - var ctx = instance.ctx; // do not cache property access on public proxy during state initialization + return false; + } // use function string name to check type constructors + // so that it works across vms / iframes. - shouldCacheAccess = false; // call beforeCreate first before accessing other options since - // the hook may mutate resolved options (#2791) - if (options.beforeCreate) { - callHook(options.beforeCreate, instance, "bc" - /* BEFORE_CREATE */ - ); + function getType(ctor) { + var match = ctor && ctor.toString().match(/^\s*function (\w+)/); + return match ? match[1] : ctor === null ? 'null' : ''; } - var { - // state - data: dataOptions, - computed: computedOptions, - methods, - watch: watchOptions, - provide: provideOptions, - inject: injectOptions, - // lifecycle - created, - beforeMount, - mounted, - beforeUpdate, - updated, - activated, - deactivated, - beforeDestroy, - beforeUnmount, - destroyed, - unmounted, - render, - renderTracked, - renderTriggered, - errorCaptured, - serverPrefetch, - // public API - expose, - inheritAttrs, - // assets - components, - directives, - filters - } = options; - var checkDuplicateProperties = createDuplicateChecker(); - { - var [propsOptions] = instance.propsOptions; + function isSameType(a, b) { + return getType(a) === getType(b); + } - if (propsOptions) { - for (var key in propsOptions) { - checkDuplicateProperties("Props" - /* PROPS */ - , key); - } + function getTypeIndex(type, expectedTypes) { + if (shared.isArray(expectedTypes)) { + return expectedTypes.findIndex(t => isSameType(t, type)); + } else if (shared.isFunction(expectedTypes)) { + return isSameType(expectedTypes, type) ? 0 : -1; } - } // options initialization order (to be consistent with Vue 2): - // - props (already done outside of this function) - // - inject - // - methods - // - data (deferred since it relies on `this` access) - // - computed - // - watch (deferred since it relies on `this` access) - if (injectOptions) { - resolveInjections(injectOptions, ctx, checkDuplicateProperties, instance.appContext.config.unwrapInjectedRef); + return -1; } + /** + * dev only + */ - if (methods) { - for (var _key9 in methods) { - var methodHandler = methods[_key9]; - if (isFunction(methodHandler)) { - // In dev mode, we use the `createRenderContext` function to define - // methods to the proxy target, and those are read-only but - // reconfigurable, so it needs to be redefined here - { - Object.defineProperty(ctx, _key9, { - value: methodHandler.bind(publicThis), - configurable: true, - enumerable: true, - writable: true - }); - } - { - checkDuplicateProperties("Methods" - /* METHODS */ - , _key9); - } - } else { - warn$1("Method \"".concat(_key9, "\" has type \"").concat(typeof methodHandler, "\" in the component definition. ") + "Did you reference the function correctly?"); - } + function validateProps(rawProps, props, instance) { + var resolvedValues = reactivity.toRaw(props); + var options = instance.propsOptions[0]; + + for (var key in options) { + var opt = options[key]; + if (opt == null) continue; + validateProp(key, resolvedValues[key], opt, !shared.hasOwn(rawProps, key) && !shared.hasOwn(rawProps, shared.hyphenate(key))); } } + /** + * dev only + */ - if (dataOptions) { - (function () { - if (!isFunction(dataOptions)) { - warn$1("The data option must be a function. " + "Plain object usage is no longer supported."); - } - - var data = dataOptions.call(publicThis, publicThis); - if (isPromise(data)) { - warn$1("data() returned a Promise - note data() cannot be async; If you " + "intend to perform data fetching before component renders, use " + "async setup() + ."); - } + function validateProp(name, value, prop, isAbsent) { + var { + type, + required, + validator + } = prop; // required! - if (!isObject(data)) { - warn$1("data() should return an object."); - } else { - instance.data = reactive(data); - { - var _loop = function (_key10) { - checkDuplicateProperties("Data" - /* DATA */ - , _key10); // expose data on ctx during dev - - if (_key10[0] !== '$' && _key10[0] !== '_') { - Object.defineProperty(ctx, _key10, { - configurable: true, - enumerable: true, - get: () => data[_key10], - set: NOOP - }); - } - }; + if (required && isAbsent) { + warn('Missing required prop: "' + name + '"'); + return; + } // missing but optional - for (var _key10 in data) { - _loop(_key10); - } - } - } - })(); - } // state initialization complete at this point - start caching access + if (value == null && !prop.required) { + return; + } // type check - shouldCacheAccess = true; - if (computedOptions) { - var _loop2 = function (_key11) { - var opt = computedOptions[_key11]; - var get = isFunction(opt) ? opt.bind(publicThis, publicThis) : isFunction(opt.get) ? opt.get.bind(publicThis, publicThis) : NOOP; + if (type != null && type !== true) { + var isValid = false; + var types = shared.isArray(type) ? type : [type]; + var expectedTypes = []; // value is valid as long as one of the specified types match - if (get === NOOP) { - warn$1("Computed property \"".concat(_key11, "\" has no getter.")); + for (var i = 0; i < types.length && !isValid; i++) { + var { + valid, + expectedType + } = assertType(value, types[i]); + expectedTypes.push(expectedType || ''); + isValid = valid; } - var set = !isFunction(opt) && isFunction(opt.set) ? opt.set.bind(publicThis) : () => { - warn$1("Write operation failed: computed property \"".concat(_key11, "\" is readonly.")); - }; - var c = computed$1({ - get, - set - }); - Object.defineProperty(ctx, _key11, { - enumerable: true, - configurable: true, - get: () => c.value, - set: v => c.value = v - }); - { - checkDuplicateProperties("Computed" - /* COMPUTED */ - , _key11); + if (!isValid) { + warn(getInvalidTypeMessage(name, value, expectedTypes)); + return; } - }; + } // custom validator - for (var _key11 in computedOptions) { - _loop2(_key11); - } - } - - if (watchOptions) { - for (var _key12 in watchOptions) { - createWatcher(watchOptions[_key12], ctx, publicThis, _key12); - } - } - - if (provideOptions) { - var provides = isFunction(provideOptions) ? provideOptions.call(publicThis) : provideOptions; - Reflect.ownKeys(provides).forEach(key => { - provide(key, provides[key]); - }); - } - if (created) { - callHook(created, instance, "c" - /* CREATED */ - ); - } - - function registerLifecycleHook(register, hook) { - if (isArray(hook)) { - hook.forEach(_hook => register(_hook.bind(publicThis))); - } else if (hook) { - register(hook.bind(publicThis)); - } - } - - registerLifecycleHook(onBeforeMount, beforeMount); - registerLifecycleHook(onMounted, mounted); - registerLifecycleHook(onBeforeUpdate, beforeUpdate); - registerLifecycleHook(onUpdated, updated); - registerLifecycleHook(onActivated, activated); - registerLifecycleHook(onDeactivated, deactivated); - registerLifecycleHook(onErrorCaptured, errorCaptured); - registerLifecycleHook(onRenderTracked, renderTracked); - registerLifecycleHook(onRenderTriggered, renderTriggered); - registerLifecycleHook(onBeforeUnmount, beforeUnmount); - registerLifecycleHook(onUnmounted, unmounted); - registerLifecycleHook(onServerPrefetch, serverPrefetch); - - if (isArray(expose)) { - if (expose.length) { - var exposed = instance.exposed || (instance.exposed = {}); - expose.forEach(key => { - Object.defineProperty(exposed, key, { - get: () => publicThis[key], - set: val => publicThis[key] = val - }); - }); - } else if (!instance.exposed) { - instance.exposed = {}; + if (validator && !validator(value)) { + warn('Invalid prop: custom validator check failed for prop "' + name + '".'); } - } // options that are handled when creating the instance but also need to be - // applied from mixins - - - if (render && instance.render === NOOP) { - instance.render = render; } - if (inheritAttrs != null) { - instance.inheritAttrs = inheritAttrs; - } // asset options. - - - if (components) instance.components = components; - if (directives) instance.directives = directives; - } - - function resolveInjections(injectOptions, ctx) { - var checkDuplicateProperties = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : NOOP; - var unwrapRef = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false; - - if (isArray(injectOptions)) { - injectOptions = normalizeInject(injectOptions); - } + var isSimpleType = /*#__PURE__*/shared.makeMap('String,Number,Boolean,Function,Symbol,BigInt'); + /** + * dev only + */ - var _loop3 = function (key) { - var opt = injectOptions[key]; - var injected = void 0; + function assertType(value, type) { + var valid; + var expectedType = getType(type); - if (isObject(opt)) { - if ('default' in opt) { - injected = inject(opt.from || key, opt.default, true - /* treat default function as factory */ - ); - } else { - injected = inject(opt.from || key); - } - } else { - injected = inject(opt); - } + if (isSimpleType(expectedType)) { + var t = typeof value; + valid = t === expectedType.toLowerCase(); // for primitive wrapper objects - if (isRef(injected)) { - // TODO remove the check in 3.3 - if (unwrapRef) { - Object.defineProperty(ctx, key, { - enumerable: true, - configurable: true, - get: () => injected.value, - set: v => injected.value = v - }); - } else { - { - warn$1("injected property \"".concat(key, "\" is a ref and will be auto-unwrapped ") + "and no longer needs `.value` in the next minor release. " + "To opt-in to the new behavior now, " + "set `app.config.unwrapInjectedRef = true` (this config is " + "temporary and will not be needed in the future.)"); - } - ctx[key] = injected; + if (!valid && t === 'object') { + valid = value instanceof type; } + } else if (expectedType === 'Object') { + valid = shared.isObject(value); + } else if (expectedType === 'Array') { + valid = shared.isArray(value); + } else if (expectedType === 'null') { + valid = value === null; } else { - ctx[key] = injected; - } - - { - checkDuplicateProperties("Inject" - /* INJECT */ - , key); + valid = value instanceof type; } - }; - for (var key in injectOptions) { - _loop3(key); + return { + valid, + expectedType + }; } - } - - function callHook(hook, instance, type) { - callWithAsyncErrorHandling(isArray(hook) ? hook.map(h => h.bind(instance.proxy)) : hook.bind(instance.proxy), instance, type); - } + /** + * dev only + */ - function createWatcher(raw, ctx, publicThis, key) { - var getter = key.includes('.') ? createPathGetter(publicThis, key) : () => publicThis[key]; - if (isString(raw)) { - var handler = ctx[raw]; + function getInvalidTypeMessage(name, value, expectedTypes) { + var message = "Invalid prop: type check failed for prop \"".concat(name, "\".") + " Expected ".concat(expectedTypes.map(shared.capitalize).join(' | ')); + var expectedType = expectedTypes[0]; + var receivedType = shared.toRawType(value); + var expectedValue = styleValue(value, expectedType); + var receivedValue = styleValue(value, receivedType); // check if we need to specify expected value - if (isFunction(handler)) { - watch(getter, handler); - } else { - warn$1("Invalid watch handler specified by key \"".concat(raw, "\""), handler); + if (expectedTypes.length === 1 && isExplicable(expectedType) && !isBoolean(expectedType, receivedType)) { + message += " with value ".concat(expectedValue); } - } else if (isFunction(raw)) { - watch(getter, raw.bind(publicThis)); - } else if (isObject(raw)) { - if (isArray(raw)) { - raw.forEach(r => createWatcher(r, ctx, publicThis, key)); - } else { - var _handler = isFunction(raw.handler) ? raw.handler.bind(publicThis) : ctx[raw.handler]; - if (isFunction(_handler)) { - watch(getter, _handler, raw); - } else { - warn$1("Invalid watch handler specified by key \"".concat(raw.handler, "\""), _handler); - } - } - } else { - warn$1("Invalid watch option: \"".concat(key, "\""), raw); - } - } - /** - * Resolve merged options and cache it on the component. - * This is done only once per-component since the merging does not involve - * instances. - */ - - - function resolveMergedOptions(instance) { - var base = instance.type; - var { - mixins, - extends: extendsOptions - } = base; - var { - mixins: globalMixins, - optionsCache: cache, - config: { - optionMergeStrategies - } - } = instance.appContext; - var cached = cache.get(base); - var resolved; - - if (cached) { - resolved = cached; - } else if (!globalMixins.length && !mixins && !extendsOptions) { - { - resolved = base; - } - } else { - resolved = {}; + message += ", got ".concat(receivedType, " "); // check if we need to specify received value - if (globalMixins.length) { - globalMixins.forEach(m => mergeOptions(resolved, m, optionMergeStrategies, true)); + if (isExplicable(receivedType)) { + message += "with value ".concat(receivedValue, "."); } - mergeOptions(resolved, base, optionMergeStrategies); - } - - cache.set(base, resolved); - return resolved; - } - - function mergeOptions(to, from, strats) { - var asMixin = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false; - var { - mixins, - extends: extendsOptions - } = from; - - if (extendsOptions) { - mergeOptions(to, extendsOptions, strats, true); + return message; } + /** + * dev only + */ - if (mixins) { - mixins.forEach(m => mergeOptions(to, m, strats, true)); - } - for (var key in from) { - if (asMixin && key === 'expose') { - warn$1("\"expose\" option is ignored when declared in mixins or extends. " + "It should only be declared in the base component itself."); + function styleValue(value, type) { + if (type === 'String') { + return "\"".concat(value, "\""); + } else if (type === 'Number') { + return "".concat(Number(value)); } else { - var strat = internalOptionMergeStrats[key] || strats && strats[key]; - to[key] = strat ? strat(to[key], from[key]) : from[key]; - } - } - - return to; - } - - var internalOptionMergeStrats = { - data: mergeDataFn, - props: mergeObjectOptions, - emits: mergeObjectOptions, - // objects - methods: mergeObjectOptions, - computed: mergeObjectOptions, - // lifecycle - beforeCreate: mergeAsArray, - created: mergeAsArray, - beforeMount: mergeAsArray, - mounted: mergeAsArray, - beforeUpdate: mergeAsArray, - updated: mergeAsArray, - beforeDestroy: mergeAsArray, - beforeUnmount: mergeAsArray, - destroyed: mergeAsArray, - unmounted: mergeAsArray, - activated: mergeAsArray, - deactivated: mergeAsArray, - errorCaptured: mergeAsArray, - serverPrefetch: mergeAsArray, - // assets - components: mergeObjectOptions, - directives: mergeObjectOptions, - // watch - watch: mergeWatchOptions, - // provide / inject - provide: mergeDataFn, - inject: mergeInject - }; - - function mergeDataFn(to, from) { - if (!from) { - return to; - } - - if (!to) { - return from; + return "".concat(value); + } } + /** + * dev only + */ - return function mergedDataFn() { - return extend(isFunction(to) ? to.call(this, this) : to, isFunction(from) ? from.call(this, this) : from); - }; - } - function mergeInject(to, from) { - return mergeObjectOptions(normalizeInject(to), normalizeInject(from)); - } + function isExplicable(type) { + var explicitTypes = ['string', 'number', 'boolean']; + return explicitTypes.some(elem => type.toLowerCase() === elem); + } + /** + * dev only + */ - function normalizeInject(raw) { - if (isArray(raw)) { - var res = {}; - for (var i = 0; i < raw.length; i++) { - res[raw[i]] = raw[i]; + function isBoolean() { + for (var _len5 = arguments.length, args = new Array(_len5), _key12 = 0; _key12 < _len5; _key12++) { + args[_key12] = arguments[_key12]; } - return res; + return args.some(elem => elem.toLowerCase() === 'boolean'); } - return raw; - } + var isInternalKey = key => key[0] === '_' || key === '$stable'; - function mergeAsArray(to, from) { - return to ? [...new Set([].concat(to, from))] : from; - } + var normalizeSlotValue = value => shared.isArray(value) ? value.map(normalizeVNode) : [normalizeVNode(value)]; - function mergeObjectOptions(to, from) { - return to ? extend(extend(Object.create(null), to), from) : from; - } + var normalizeSlot = (key, rawSlot, ctx) => { + var normalized = withCtx(function () { + if (currentInstance) { + warn("Slot \"".concat(key, "\" invoked outside of the render function: ") + "this will not track dependencies used in the slot. " + "Invoke the slot function inside the render function instead."); + } - function mergeWatchOptions(to, from) { - if (!to) return from; - if (!from) return to; - var merged = extend(Object.create(null), to); + return normalizeSlotValue(rawSlot(...arguments)); + }, ctx); + normalized._c = false; + return normalized; + }; - for (var key in from) { - merged[key] = mergeAsArray(to[key], from[key]); - } + var normalizeObjectSlots = (rawSlots, slots, instance) => { + var ctx = rawSlots._ctx; - return merged; - } + for (var key in rawSlots) { + if (isInternalKey(key)) continue; + var value = rawSlots[key]; - function initProps(instance, rawProps, isStateful) { - var isSSR = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false; - var props = {}; - var attrs = {}; - def(attrs, InternalObjectKey, 1); - instance.propsDefaults = Object.create(null); - setFullProps(instance, rawProps, props, attrs); // ensure all declared prop keys are present + if (shared.isFunction(value)) { + slots[key] = normalizeSlot(key, value, ctx); + } else if (value != null) { + (function () { + { + warn("Non-function value encountered for slot \"".concat(key, "\". ") + "Prefer function slots for better performance."); + } + var normalized = normalizeSlotValue(value); - for (var key in instance.propsOptions[0]) { - if (!(key in props)) { - props[key] = undefined; + slots[key] = () => normalized; + })(); + } } - } // validation - - - { - validateProps(rawProps || {}, props, instance); - } + }; - if (isStateful) { - // stateful - instance.props = isSSR ? props : shallowReactive(props); - } else { - if (!instance.type.props) { - // functional w/ optional props, props === attrs - instance.props = attrs; - } else { - // functional w/ declared props - instance.props = props; + var normalizeVNodeSlots = (instance, children) => { + if (!isKeepAlive(instance.vnode) && !false) { + warn("Non-function value encountered for default slot. " + "Prefer function slots for better performance."); } - } - instance.attrs = attrs; - } + var normalized = normalizeSlotValue(children); - function updateProps(instance, rawProps, rawPrevProps, optimized) { - var { - props, - attrs, - vnode: { - patchFlag - } - } = instance; - var rawCurrentProps = toRaw(props); - var [options] = instance.propsOptions; - var hasAttrsChanged = false; - - if ( // always force full diff in dev - // - #1942 if hmr is enabled with sfc component - // - vite#872 non-sfc component used by sfc component - !(instance.type.__hmrId || instance.parent && instance.parent.type.__hmrId) && (optimized || patchFlag > 0) && !(patchFlag & 16 - /* FULL_PROPS */ - )) { - if (patchFlag & 8 - /* PROPS */ + instance.slots.default = () => normalized; + }; + + var initSlots = (instance, children) => { + if (instance.vnode.shapeFlag & 32 + /* SLOTS_CHILDREN */ ) { - // Compiler-generated props & no keys change, just set the updated - // the props. - var propsToUpdate = instance.vnode.dynamicProps; + var type = children._; - for (var i = 0; i < propsToUpdate.length; i++) { - var key = propsToUpdate[i]; // PROPS flag guarantees rawProps to be non-null + if (type) { + // users can get the shallow readonly version of the slots object through `this.$slots`, + // we should avoid the proxy object polluting the slots of the internal instance + instance.slots = reactivity.toRaw(children); // make compiler marker non-enumerable - var value = rawProps[key]; + shared.def(children, '_', type); + } else { + normalizeObjectSlots(children, instance.slots = {}); + } + } else { + instance.slots = {}; - if (options) { - // attr / props separation was done on init and will be consistent - // in this code path, so just check if attrs have it. - if (hasOwn(attrs, key)) { - if (value !== attrs[key]) { - attrs[key] = value; - hasAttrsChanged = true; - } - } else { - var camelizedKey = camelize(key); - props[camelizedKey] = resolvePropValue(options, rawCurrentProps, camelizedKey, value, instance, false - /* isAbsent */ - ); - } - } else { - if (value !== attrs[key]) { - attrs[key] = value; - hasAttrsChanged = true; - } - } + if (children) { + normalizeVNodeSlots(instance, children); } } - } else { - // full props update. - if (setFullProps(instance, rawProps, props, attrs)) { - hasAttrsChanged = true; - } // in case of dynamic props, check if we need to delete keys from - // the props object + shared.def(instance.slots, InternalObjectKey, 1); + }; - var kebabKey; + var updateSlots = (instance, children, optimized) => { + var { + vnode, + slots + } = instance; + var needDeletionCheck = true; + var deletionComparisonTarget = shared.EMPTY_OBJ; - for (var _key13 in rawCurrentProps) { - if (!rawProps || // for camelCase - !hasOwn(rawProps, _key13) && ( // it's possible the original props was passed in as kebab-case - // and converted to camelCase (#955) - (kebabKey = hyphenate(_key13)) === _key13 || !hasOwn(rawProps, kebabKey))) { - if (options) { - if (rawPrevProps && ( // for camelCase - rawPrevProps[_key13] !== undefined || // for kebab-case - rawPrevProps[kebabKey] !== undefined)) { - props[_key13] = resolvePropValue(options, rawCurrentProps, _key13, undefined, instance, true - /* isAbsent */ - ); - } + if (vnode.shapeFlag & 32 + /* SLOTS_CHILDREN */ + ) { + var type = children._; + + if (type) { + // compiled slots. + if (isHmrUpdating) { + // Parent was HMR updated so slot content may have changed. + // force update slots and mark instance for hmr as well + shared.extend(slots, children); + } else if (optimized && type === 1 + /* STABLE */ + ) { + // compiled AND stable. + // no need to update, and skip stale slots removal. + needDeletionCheck = false; } else { - delete props[_key13]; - } - } - } // 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 (var _key14 in attrs) { - if (!rawProps || !hasOwn(rawProps, _key14) && !false) { - delete attrs[_key14]; - hasAttrsChanged = true; + // compiled but dynamic (v-if/v-for on slots) - update slots, but skip + // normalization. + shared.extend(slots, children); // #2893 + // when rendering the optimized slots by manually written render function, + // we need to delete the `slots._` flag if necessary to make subsequent updates reliable, + // i.e. let the `renderSlot` create the bailed Fragment + + if (!optimized && type === 1 + /* STABLE */ + ) { + delete slots._; + } } - } - } - } // trigger updates for $attrs in case it's used in component slots - - - if (hasAttrsChanged) { - trigger(instance, "set" - /* SET */ - , '$attrs'); - } - - { - validateProps(rawProps || {}, props, instance); - } - } - - function setFullProps(instance, rawProps, props, attrs) { - var [options, needCastKeys] = instance.propsOptions; - var hasAttrsChanged = false; - var rawCastValues; - - if (rawProps) { - for (var key in rawProps) { - // key, ref are reserved and never passed down - if (isReservedProp(key)) { - continue; + } else { + needDeletionCheck = !children.$stable; + normalizeObjectSlots(children, slots); } - var value = rawProps[key]; // prop option names are camelized during normalization, so to support - // kebab -> camel conversion here we need to camelize the key. + deletionComparisonTarget = children; + } else if (children) { + // non slot object children (direct value) passed to a component + normalizeVNodeSlots(instance, children); + deletionComparisonTarget = { + default: 1 + }; + } // delete stale slots - var camelKey = void 0; - if (options && hasOwn(options, camelKey = camelize(key))) { - if (!needCastKeys || !needCastKeys.includes(camelKey)) { - props[camelKey] = value; - } else { - (rawCastValues || (rawCastValues = {}))[camelKey] = value; - } - } else if (!isEmitListener(instance.emitsOptions, key)) { - if (!(key in attrs) || value !== attrs[key]) { - attrs[key] = value; - hasAttrsChanged = true; + if (needDeletionCheck) { + for (var key in slots) { + if (!isInternalKey(key) && !(key in deletionComparisonTarget)) { + delete slots[key]; } } } - } + }; + /** + Runtime helper for applying directives to a vnode. Example usage: + const comp = resolveComponent('comp') + const foo = resolveDirective('foo') + const bar = resolveDirective('bar') + return withDirectives(h(comp), [ + [foo, this.x], + [bar, this.y] + ]) + */ - if (needCastKeys) { - var rawCurrentProps = toRaw(props); - var castValues = rawCastValues || EMPTY_OBJ; - for (var i = 0; i < needCastKeys.length; i++) { - var _key15 = needCastKeys[i]; - props[_key15] = resolvePropValue(options, rawCurrentProps, _key15, castValues[_key15], instance, !hasOwn(castValues, _key15)); + function validateDirectiveName(name) { + if (shared.isBuiltInDirective(name)) { + warn('Do not use built-in directive ids as custom directive id: ' + name); } } + /** + * Adds directives to a VNode. + */ - return hasAttrsChanged; - } - function resolvePropValue(options, props, key, value, instance, isAbsent) { - var opt = options[key]; + function withDirectives(vnode, directives) { + var internalInstance = currentRenderingInstance; - if (opt != null) { - var hasDefault = hasOwn(opt, 'default'); // default values + if (internalInstance === null) { + warn("withDirectives can only be used inside render functions."); + return vnode; + } - if (hasDefault && value === undefined) { - var defaultValue = opt.default; + var instance = internalInstance.proxy; + var bindings = vnode.dirs || (vnode.dirs = []); - if (opt.type !== Function && isFunction(defaultValue)) { - var { - propsDefaults - } = instance; + for (var i = 0; i < directives.length; i++) { + var [dir, value, arg, modifiers = shared.EMPTY_OBJ] = directives[i]; - if (key in propsDefaults) { - value = propsDefaults[key]; - } else { - setCurrentInstance(instance); - value = propsDefaults[key] = defaultValue.call(null, props); - unsetCurrentInstance(); - } - } else { - value = defaultValue; + if (shared.isFunction(dir)) { + dir = { + mounted: dir, + updated: dir + }; } - } // boolean casting - - if (opt[0 - /* shouldCast */ - ]) { - if (isAbsent && !hasDefault) { - value = false; - } else if (opt[1 - /* shouldCastTrue */ - ] && (value === '' || value === hyphenate(key))) { - value = true; + if (dir.deep) { + traverse(value); } - } - } - return value; - } - - function normalizePropsOptions(comp, appContext) { - var asMixin = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; - var cache = appContext.propsCache; - var cached = cache.get(comp); + bindings.push({ + dir, + instance, + value, + oldValue: void 0, + arg, + modifiers + }); + } - if (cached) { - return cached; + return vnode; } - var raw = comp.props; - var normalized = {}; - var needCastKeys = []; // apply mixin/extends props + function invokeDirectiveHook(vnode, prevVNode, instance, name) { + var bindings = vnode.dirs; + var oldBindings = prevVNode && prevVNode.dirs; - var hasExtends = false; - - if (!isFunction(comp)) { - var extendProps = raw => { - hasExtends = true; - var [props, keys] = normalizePropsOptions(raw, appContext, true); - extend(normalized, props); - if (keys) needCastKeys.push(...keys); - }; + for (var i = 0; i < bindings.length; i++) { + var binding = bindings[i]; - if (!asMixin && appContext.mixins.length) { - appContext.mixins.forEach(extendProps); - } + if (oldBindings) { + binding.oldValue = oldBindings[i].value; + } - if (comp.extends) { - extendProps(comp.extends); - } + var hook = binding.dir[name]; - if (comp.mixins) { - comp.mixins.forEach(extendProps); + if (hook) { + // disable tracking inside all lifecycle hooks + // since they can potentially be called inside effects. + reactivity.pauseTracking(); + callWithAsyncErrorHandling(hook, instance, 8 + /* DIRECTIVE_HOOK */ + , [vnode.el, binding, vnode, prevVNode]); + reactivity.resetTracking(); + } } } - if (!raw && !hasExtends) { - cache.set(comp, EMPTY_ARR); - return EMPTY_ARR; + function createAppContext() { + return { + app: null, + config: { + isNativeTag: shared.NO, + performance: false, + globalProperties: {}, + optionMergeStrategies: {}, + errorHandler: undefined, + warnHandler: undefined, + compilerOptions: {} + }, + mixins: [], + components: {}, + directives: {}, + provides: Object.create(null), + optionsCache: new WeakMap(), + propsCache: new WeakMap(), + emitsCache: new WeakMap() + }; } - if (isArray(raw)) { - for (var i = 0; i < raw.length; i++) { - if (!isString(raw[i])) { - warn$1("props must be strings when using array syntax.", raw[i]); - } + var uid = 0; - var normalizedKey = camelize(raw[i]); + function createAppAPI(render, hydrate) { + return function createApp(rootComponent) { + var rootProps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null; - if (validatePropName(normalizedKey)) { - normalized[normalizedKey] = EMPTY_OBJ; + if (rootProps != null && !shared.isObject(rootProps)) { + warn("root props passed to app.mount() must be an object."); + rootProps = null; } - } - } else if (raw) { - if (!isObject(raw)) { - warn$1("invalid props options", raw); - } - - for (var key in raw) { - var _normalizedKey = camelize(key); - if (validatePropName(_normalizedKey)) { - var opt = raw[key]; - var prop = normalized[_normalizedKey] = isArray(opt) || isFunction(opt) ? { - type: opt - } : opt; + var context = createAppContext(); + var installedPlugins = new Set(); + var isMounted = false; + var app = context.app = { + _uid: uid++, + _component: rootComponent, + _props: rootProps, + _container: null, + _context: context, + _instance: null, + version, - if (prop) { - var booleanIndex = getTypeIndex(Boolean, prop.type); - var 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 + get config() { + return context.config; + }, - if (booleanIndex > -1 || hasOwn(prop, 'default')) { - needCastKeys.push(_normalizedKey); + set config(v) { + { + warn("app.config cannot be replaced. Modify individual options instead."); } - } - } - } - } + }, - var res = [normalized, needCastKeys]; - cache.set(comp, res); - return res; - } + use(plugin) { + for (var _len6 = arguments.length, options = new Array(_len6 > 1 ? _len6 - 1 : 0), _key13 = 1; _key13 < _len6; _key13++) { + options[_key13 - 1] = arguments[_key13]; + } - function validatePropName(key) { - if (key[0] !== '$') { - return true; - } else { - warn$1("Invalid prop name: \"".concat(key, "\" is a reserved property.")); - } + if (installedPlugins.has(plugin)) { + warn("Plugin has already been applied to target app."); + } else if (plugin && shared.isFunction(plugin.install)) { + installedPlugins.add(plugin); + plugin.install(app, ...options); + } else if (shared.isFunction(plugin)) { + installedPlugins.add(plugin); + plugin(app, ...options); + } else { + warn("A plugin must either be a function or an object with an \"install\" " + "function."); + } - return false; - } // use function string name to check type constructors - // so that it works across vms / iframes. + return app; + }, + mixin(mixin) { + { + if (!context.mixins.includes(mixin)) { + context.mixins.push(mixin); + } else { + warn('Mixin has already been applied to target app' + (mixin.name ? ": ".concat(mixin.name) : '')); + } + } + return app; + }, - function getType(ctor) { - var match = ctor && ctor.toString().match(/^\s*function (\w+)/); - return match ? match[1] : ctor === null ? 'null' : ''; - } + component(name, component) { + { + validateComponentName(name, context.config); + } - function isSameType(a, b) { - return getType(a) === getType(b); - } + if (!component) { + return context.components[name]; + } - function getTypeIndex(type, expectedTypes) { - if (isArray(expectedTypes)) { - return expectedTypes.findIndex(t => isSameType(t, type)); - } else if (isFunction(expectedTypes)) { - return isSameType(expectedTypes, type) ? 0 : -1; - } + if (context.components[name]) { + warn("Component \"".concat(name, "\" has already been registered in target app.")); + } - return -1; - } - /** - * dev only - */ + context.components[name] = component; + return app; + }, + directive(name, directive) { + { + validateDirectiveName(name); + } - function validateProps(rawProps, props, instance) { - var resolvedValues = toRaw(props); - var options = instance.propsOptions[0]; + if (!directive) { + return context.directives[name]; + } - for (var key in options) { - var opt = options[key]; - if (opt == null) continue; - validateProp(key, resolvedValues[key], opt, !hasOwn(rawProps, key) && !hasOwn(rawProps, hyphenate(key))); - } - } - /** - * dev only - */ + if (context.directives[name]) { + warn("Directive \"".concat(name, "\" has already been registered in target app.")); + } + context.directives[name] = directive; + return app; + }, - function validateProp(name, value, prop, isAbsent) { - var { - type, - required, - validator - } = prop; // required! + mount(rootContainer, isHydrate, isSVG) { + if (!isMounted) { + var vnode = createVNode(rootComponent, rootProps); // store app context on the root VNode. + // this will be set on the root instance on initial mount. - if (required && isAbsent) { - warn$1('Missing required prop: "' + name + '"'); - return; - } // missing but optional + vnode.appContext = context; // HMR root reload + { + context.reload = () => { + render(cloneVNode(vnode), rootContainer, isSVG); + }; + } - if (value == null && !prop.required) { - return; - } // type check + if (isHydrate && hydrate) { + hydrate(vnode, rootContainer); + } else { + render(vnode, rootContainer, isSVG); + } + isMounted = true; + app._container = rootContainer; + rootContainer.__vue_app__ = app; + { + app._instance = vnode.component; + devtoolsInitApp(app, version); + } + return getExposeProxy(vnode.component) || vnode.component.proxy; + } else { + warn("App has already been mounted.\n" + "If you want to remount the same app, move your app creation logic " + "into a factory function and create fresh app instances for each " + "mount - e.g. `const createMyApp = () => createApp(App)`"); + } + }, - if (type != null && type !== true) { - var isValid = false; - var types = isArray(type) ? type : [type]; - var expectedTypes = []; // value is valid as long as one of the specified types match + unmount() { + if (isMounted) { + render(null, app._container); + { + app._instance = null; + devtoolsUnmountApp(app); + } + delete app._container.__vue_app__; + } else { + warn("Cannot unmount an app that is not mounted."); + } + }, - for (var i = 0; i < types.length && !isValid; i++) { - var { - valid, - expectedType - } = assertType(value, types[i]); - expectedTypes.push(expectedType || ''); - isValid = valid; - } + provide(key, value) { + if (key in context.provides) { + warn("App already provides property with key \"".concat(String(key), "\". ") + "It will be overwritten with the new value."); + } // TypeScript doesn't allow symbols as index type + // https://github.com/Microsoft/TypeScript/issues/24587 - if (!isValid) { - warn$1(getInvalidTypeMessage(name, value, expectedTypes)); - return; - } - } // custom validator + context.provides[key] = value; + return app; + } - if (validator && !validator(value)) { - warn$1('Invalid prop: custom validator check failed for prop "' + name + '".'); + }; + return app; + }; } - } - - var isSimpleType = /*#__PURE__*/makeMap('String,Number,Boolean,Function,Symbol,BigInt'); - /** - * dev only - */ + /** + * Function for handling a template ref + */ - function assertType(value, type) { - var valid; - var expectedType = getType(type); - if (isSimpleType(expectedType)) { - var t = typeof value; - valid = t === expectedType.toLowerCase(); // for primitive wrapper objects + function setRef(rawRef, oldRawRef, parentSuspense, vnode) { + var isUnmount = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false; - if (!valid && t === 'object') { - valid = value instanceof type; + if (shared.isArray(rawRef)) { + rawRef.forEach((r, i) => setRef(r, oldRawRef && (shared.isArray(oldRawRef) ? oldRawRef[i] : oldRawRef), parentSuspense, vnode, isUnmount)); + return; } - } else if (expectedType === 'Object') { - valid = isObject(value); - } else if (expectedType === 'Array') { - valid = isArray(value); - } else if (expectedType === 'null') { - valid = value === null; - } else { - valid = value instanceof type; - } - - return { - valid, - expectedType - }; - } - /** - * dev only - */ + if (isAsyncWrapper(vnode) && !isUnmount) { + // when mounting async components, nothing needs to be done, + // because the template ref is forwarded to inner component + return; + } - function getInvalidTypeMessage(name, value, expectedTypes) { - var message = "Invalid prop: type check failed for prop \"".concat(name, "\".") + " Expected ".concat(expectedTypes.map(capitalize).join(' | ')); - var expectedType = expectedTypes[0]; - var receivedType = toRawType(value); - var expectedValue = styleValue(value, expectedType); - var receivedValue = styleValue(value, receivedType); // check if we need to specify expected value + var refValue = vnode.shapeFlag & 4 + /* STATEFUL_COMPONENT */ + ? getExposeProxy(vnode.component) || vnode.component.proxy : vnode.el; + var value = isUnmount ? null : refValue; + var { + i: owner, + r: ref + } = rawRef; - if (expectedTypes.length === 1 && isExplicable(expectedType) && !isBoolean(expectedType, receivedType)) { - message += " with value ".concat(expectedValue); - } + if (!owner) { + warn("Missing ref owner context. ref cannot be used on hoisted vnodes. " + "A vnode with ref must be created inside the render function."); + return; + } - message += ", got ".concat(receivedType, " "); // check if we need to specify received value + var oldRef = oldRawRef && oldRawRef.r; + var refs = owner.refs === shared.EMPTY_OBJ ? owner.refs = {} : owner.refs; + var setupState = owner.setupState; // dynamic ref changed. unset old ref - if (isExplicable(receivedType)) { - message += "with value ".concat(receivedValue, "."); - } + if (oldRef != null && oldRef !== ref) { + if (shared.isString(oldRef)) { + refs[oldRef] = null; - return message; - } - /** - * dev only - */ + if (shared.hasOwn(setupState, oldRef)) { + setupState[oldRef] = null; + } + } else if (reactivity.isRef(oldRef)) { + oldRef.value = null; + } + } + if (shared.isFunction(ref)) { + callWithErrorHandling(ref, owner, 12 + /* FUNCTION_REF */ + , [value, refs]); + } else { + var _isString = shared.isString(ref); - function styleValue(value, type) { - if (type === 'String') { - return "\"".concat(value, "\""); - } else if (type === 'Number') { - return "".concat(Number(value)); - } else { - return "".concat(value); - } - } - /** - * dev only - */ + var _isRef = reactivity.isRef(ref); + if (_isString || _isRef) { + var doSet = () => { + if (rawRef.f) { + var existing = _isString ? refs[ref] : ref.value; - function isExplicable(type) { - var explicitTypes = ['string', 'number', 'boolean']; - return explicitTypes.some(elem => type.toLowerCase() === elem); - } - /** - * dev only - */ + if (isUnmount) { + shared.isArray(existing) && shared.remove(existing, refValue); + } else { + if (!shared.isArray(existing)) { + if (_isString) { + refs[ref] = [refValue]; + } else { + ref.value = [refValue]; + if (rawRef.k) refs[rawRef.k] = ref.value; + } + } else if (!existing.includes(refValue)) { + existing.push(refValue); + } + } + } else if (_isString) { + refs[ref] = value; + if (shared.hasOwn(setupState, ref)) { + setupState[ref] = value; + } + } else if (reactivity.isRef(ref)) { + ref.value = value; + if (rawRef.k) refs[rawRef.k] = value; + } else { + warn('Invalid template ref type:', ref, "(".concat(typeof ref, ")")); + } + }; - function isBoolean() { - for (var _len8 = arguments.length, args = new Array(_len8), _key16 = 0; _key16 < _len8; _key16++) { - args[_key16] = arguments[_key16]; + if (value) { + doSet.id = -1; + queuePostRenderEffect(doSet, parentSuspense); + } else { + doSet(); + } + } else { + warn('Invalid template ref type:', ref, "(".concat(typeof ref, ")")); + } + } } - return args.some(elem => elem.toLowerCase() === 'boolean'); - } - - var isInternalKey = key => key[0] === '_' || key === '$stable'; + var hasMismatch = false; - var normalizeSlotValue = value => isArray(value) ? value.map(normalizeVNode) : [normalizeVNode(value)]; + var isSVGContainer = container => /svg/.test(container.namespaceURI) && container.tagName !== 'foreignObject'; - var normalizeSlot = (key, rawSlot, ctx) => { - var normalized = withCtx(function () { - if (currentInstance) { - warn$1("Slot \"".concat(key, "\" invoked outside of the render function: ") + "this will not track dependencies used in the slot. " + "Invoke the slot function inside the render function instead."); - } + var isComment = node => node.nodeType === 8 + /* COMMENT */ + ; // Note: hydration is DOM-specific + // But we have to place it in core due to tight coupling with core - splitting + // it out creates a ton of unnecessary complexity. + // Hydration also depends on some renderer internal logic which needs to be + // passed in via arguments. - return normalizeSlotValue(rawSlot(...arguments)); - }, ctx); - normalized._c = false; - return normalized; - }; - var normalizeObjectSlots = (rawSlots, slots, instance) => { - var ctx = rawSlots._ctx; + function createHydrationFunctions(rendererInternals) { + var { + mt: mountComponent, + p: patch, + o: { + patchProp, + nextSibling, + parentNode, + remove, + insert, + createComment + } + } = rendererInternals; - for (var key in rawSlots) { - if (isInternalKey(key)) continue; - var value = rawSlots[key]; + var hydrate = (vnode, container) => { + if (!container.hasChildNodes()) { + warn("Attempting to hydrate existing markup but container is empty. " + "Performing full mount instead."); + patch(null, vnode, container); + flushPostFlushCbs(); + return; + } - if (isFunction(value)) { - slots[key] = normalizeSlot(key, value, ctx); - } else if (value != null) { - (function () { - { - warn$1("Non-function value encountered for slot \"".concat(key, "\". ") + "Prefer function slots for better performance."); - } - var normalized = normalizeSlotValue(value); + hasMismatch = false; + hydrateNode(container.firstChild, vnode, null, null, null); + flushPostFlushCbs(); - slots[key] = () => normalized; - })(); - } - } - }; + if (hasMismatch && !false) { + // this error should show up in production + console.error("Hydration completed but contains mismatches."); + } + }; - var normalizeVNodeSlots = (instance, children) => { - if (!isKeepAlive(instance.vnode) && !false) { - warn$1("Non-function value encountered for default slot. " + "Prefer function slots for better performance."); - } + var hydrateNode = function (node, vnode, parentComponent, parentSuspense, slotScopeIds) { + var optimized = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : false; + var isFragmentStart = isComment(node) && node.data === '['; - var normalized = normalizeSlotValue(children); + var onMismatch = () => handleMismatch(node, vnode, parentComponent, parentSuspense, slotScopeIds, isFragmentStart); - instance.slots.default = () => normalized; - }; + var { + type, + ref, + shapeFlag + } = vnode; + var domType = node.nodeType; + vnode.el = node; + var nextNode = null; + + switch (type) { + case Text: + if (domType !== 3 + /* TEXT */ + ) { + nextNode = onMismatch(); + } else { + if (node.data !== vnode.children) { + hasMismatch = true; + warn("Hydration text mismatch:" + "\n- Client: ".concat(JSON.stringify(node.data)) + "\n- Server: ".concat(JSON.stringify(vnode.children))); + node.data = vnode.children; + } - var initSlots = (instance, children) => { - if (instance.vnode.shapeFlag & 32 - /* SLOTS_CHILDREN */ - ) { - var type = children._; + nextNode = nextSibling(node); + } - if (type) { - // users can get the shallow readonly version of the slots object through `this.$slots`, - // we should avoid the proxy object polluting the slots of the internal instance - instance.slots = toRaw(children); // make compiler marker non-enumerable + break; - def(children, '_', type); - } else { - normalizeObjectSlots(children, instance.slots = {}); - } - } else { - instance.slots = {}; + case Comment: + if (domType !== 8 + /* COMMENT */ + || isFragmentStart) { + nextNode = onMismatch(); + } else { + nextNode = nextSibling(node); + } - if (children) { - normalizeVNodeSlots(instance, children); - } - } + break; - def(instance.slots, InternalObjectKey, 1); - }; + case Static: + if (domType !== 1 + /* ELEMENT */ + ) { + nextNode = onMismatch(); + } else { + // determine anchor, adopt content + nextNode = node; // if the static vnode has its content stripped during build, + // adopt it from the server-rendered HTML. - var updateSlots = (instance, children, optimized) => { - var { - vnode, - slots - } = instance; - var needDeletionCheck = true; - var deletionComparisonTarget = EMPTY_OBJ; + var needToAdoptContent = !vnode.children.length; - if (vnode.shapeFlag & 32 - /* SLOTS_CHILDREN */ - ) { - var type = children._; + for (var i = 0; i < vnode.staticCount; i++) { + if (needToAdoptContent) vnode.children += nextNode.outerHTML; - if (type) { - // compiled slots. - if (isHmrUpdating) { - // Parent was HMR updated so slot content may have changed. - // force update slots and mark instance for hmr as well - extend(slots, children); - } else if (optimized && type === 1 - /* STABLE */ - ) { - // compiled AND stable. - // no need to update, and skip stale slots removal. - needDeletionCheck = false; - } else { - // compiled but dynamic (v-if/v-for on slots) - update slots, but skip - // normalization. - extend(slots, children); // #2893 - // when rendering the optimized slots by manually written render function, - // we need to delete the `slots._` flag if necessary to make subsequent updates reliable, - // i.e. let the `renderSlot` create the bailed Fragment - - if (!optimized && type === 1 - /* STABLE */ - ) { - delete slots._; - } - } - } else { - needDeletionCheck = !children.$stable; - normalizeObjectSlots(children, slots); - } + if (i === vnode.staticCount - 1) { + vnode.anchor = nextNode; + } - deletionComparisonTarget = children; - } else if (children) { - // non slot object children (direct value) passed to a component - normalizeVNodeSlots(instance, children); - deletionComparisonTarget = { - default: 1 - }; - } // delete stale slots + nextNode = nextSibling(nextNode); + } + return nextNode; + } - if (needDeletionCheck) { - for (var key in slots) { - if (!isInternalKey(key) && !(key in deletionComparisonTarget)) { - delete slots[key]; - } - } - } - }; - /** - Runtime helper for applying directives to a vnode. Example usage: - - const comp = resolveComponent('comp') - const foo = resolveDirective('foo') - const bar = resolveDirective('bar') - - return withDirectives(h(comp), [ - [foo, this.x], - [bar, this.y] - ]) - */ + break; + case Fragment: + if (!isFragmentStart) { + nextNode = onMismatch(); + } else { + nextNode = hydrateFragment(node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized); + } - function validateDirectiveName(name) { - if (isBuiltInDirective(name)) { - warn$1('Do not use built-in directive ids as custom directive id: ' + name); - } - } - /** - * Adds directives to a VNode. - */ + break; + default: + if (shapeFlag & 1 + /* ELEMENT */ + ) { + if (domType !== 1 + /* ELEMENT */ + || vnode.type.toLowerCase() !== node.tagName.toLowerCase()) { + nextNode = onMismatch(); + } else { + nextNode = hydrateElement(node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized); + } + } else if (shapeFlag & 6 + /* COMPONENT */ + ) { + // when setting up the render effect, if the initial vnode already + // has .el set, the component will perform hydration instead of mount + // on its sub-tree. + vnode.slotScopeIds = slotScopeIds; + var container = parentNode(node); + mountComponent(vnode, container, null, parentComponent, parentSuspense, isSVGContainer(container), optimized); // component may be async, so in the case of fragments we cannot rely + // on component's rendered output to determine the end of the fragment + // instead, we do a lookahead to find the end anchor node. + + nextNode = isFragmentStart ? locateClosingAsyncAnchor(node) : nextSibling(node); // #3787 + // if component is async, it may get moved / unmounted before its + // inner component is loaded, so we need to give it a placeholder + // vnode that matches its adopted DOM. + + if (isAsyncWrapper(vnode)) { + var subTree; + + if (isFragmentStart) { + subTree = createVNode(Fragment); + subTree.anchor = nextNode ? nextNode.previousSibling : container.lastChild; + } else { + subTree = node.nodeType === 3 ? createTextVNode('') : createVNode('div'); + } - function withDirectives(vnode, directives) { - var internalInstance = currentRenderingInstance; + subTree.el = node; + vnode.component.subTree = subTree; + } + } else if (shapeFlag & 64 + /* TELEPORT */ + ) { + if (domType !== 8 + /* COMMENT */ + ) { + nextNode = onMismatch(); + } else { + nextNode = vnode.type.hydrate(node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized, rendererInternals, hydrateChildren); + } + } else if (shapeFlag & 128 + /* SUSPENSE */ + ) { + nextNode = vnode.type.hydrate(node, vnode, parentComponent, parentSuspense, isSVGContainer(parentNode(node)), slotScopeIds, optimized, rendererInternals, hydrateNode); + } else { + warn('Invalid HostVNode type:', type, "(".concat(typeof type, ")")); + } - if (internalInstance === null) { - warn$1("withDirectives can only be used inside render functions."); - return vnode; - } + } - var instance = internalInstance.proxy; - var bindings = vnode.dirs || (vnode.dirs = []); + if (ref != null) { + setRef(ref, null, parentSuspense, vnode); + } - for (var i = 0; i < directives.length; i++) { - var [dir, value, arg, modifiers = EMPTY_OBJ] = directives[i]; + return nextNode; + }; - if (isFunction(dir)) { - dir = { - mounted: dir, - updated: dir - }; - } + var hydrateElement = (el, vnode, parentComponent, parentSuspense, slotScopeIds, optimized) => { + optimized = optimized || !!vnode.dynamicChildren; + var { + type, + props, + patchFlag, + shapeFlag, + dirs + } = vnode; // #4006 for form elements with non-string v-model value bindings + // e.g.