// fix env try { if (!global) global = {} global.process = global.process || {} global.process.env = global.process.env || {} global.App = global.App || App global.Page = global.Page || Page global.Component = global.Component || Component global.getApp = global.getApp || getApp } catch (e) {} ;(function(global, factory) { typeof exports === "object" && typeof module !== "undefined" ? (module.exports = factory()) : typeof define === "function" && define.amd ? define(factory) : (global.Vue = factory()) })(this, function() { "use strict" //fixed by xxxxxx function calcDiff(holder, key, newObj, oldObj) { if (newObj === oldObj || newObj === undefined) { return } if (newObj == null || oldObj == null || typeof newObj !== typeof oldObj) { holder[key] = newObj } else if (Array.isArray(newObj) && Array.isArray(oldObj)) { if (newObj.length === oldObj.length) { for (var i = 0, len = newObj.length; i < len; ++i) { calcDiff(holder, key + "[" + i + "]", newObj[i], oldObj[i]) } } else { holder[key] = newObj } } else if (typeof newObj === "object" && typeof oldObj === "object") { var newKeys = Object.keys(newObj) var oldKeys = Object.keys(oldObj) if (newKeys.length !== oldKeys.length) { holder[key] = newObj } else { var allKeysSet = Object.create(null) for (var i = 0, len = newKeys.length; i < len; ++i) { allKeysSet[newKeys[i]] = true allKeysSet[oldKeys[i]] = true } if (Object.keys(allKeysSet).length !== newKeys.length) { holder[key] = newObj } else { for (var i = 0, len = newKeys.length; i < len; ++i) { var k = newKeys[i] calcDiff(holder, key + "." + k, newObj[k], oldObj[k]) } } } } else if (newObj !== oldObj) { holder[key] = newObj } } function diff(newObj, oldObj) { var keys = Object.keys(newObj) var diffResult = {} for (var i = 0, len = keys.length; i < len; ++i) { var k = keys[i] var oldKeyPath = k.split(".") var oldValue = oldObj[oldKeyPath[0]] for (var j = 1, jlen = oldKeyPath.length; j < jlen && oldValue !== undefined; ++j) { oldValue = oldValue[oldKeyPath[j]] } calcDiff(diffResult, k, newObj[k], oldValue) } return diffResult } /* */ // these helpers produces better vm code in JS engines due to their // explicitness and function inlining function isUndef(v) { return v === undefined || v === null } function isDef(v) { return v !== undefined && v !== null } function isTrue(v) { return v === true } function isFalse(v) { return v === false } /** * Check if value is primitive */ function isPrimitive(value) { return typeof value === "string" || typeof value === "number" } /** * Quick object check - this is primarily used to tell * Objects from primitive values when we know the value * is a JSON-compliant type. */ function isObject(obj) { return obj !== null && typeof obj === "object" } var _toString = Object.prototype.toString /** * Strict object type check. Only returns true * for plain JavaScript objects. */ function isPlainObject(obj) { return _toString.call(obj) === "[object Object]" } function isRegExp(v) { return _toString.call(v) === "[object RegExp]" } /** * Check if val is a valid array index. */ function isValidArrayIndex(val) { var n = parseFloat(val) return n >= 0 && Math.floor(n) === n && isFinite(val) } /** * Convert a value to a string that is actually rendered. */ function toString(val) { return val == null ? "" : typeof val === "object" ? JSON.stringify(val, null, 2) : String(val) } /** * Convert a input value to a number for persistence. * If the conversion fails, return original string. */ function toNumber(val) { var n = parseFloat(val) return isNaN(n) ? val : n } /** * Make a map and return a function for checking if a key * is in that map. */ 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 ? function(val) { return map[val.toLowerCase()] } : function(val) { return map[val] } } /** * Check if a tag is a built-in tag. */ var isBuiltInTag = makeMap("slot,component", true) /** * Check if a attribute is a reserved attribute. */ var isReservedAttribute = makeMap("key,ref,slot,is") /** * Remove an item from an array */ function remove(arr, item) { if (arr.length) { var index = arr.indexOf(item) if (index > -1) { return arr.splice(index, 1) } } } /** * Check whether the object has the property. */ var hasOwnProperty = Object.prototype.hasOwnProperty function hasOwn(obj, key) { return hasOwnProperty.call(obj, key) } /** * Create a cached version of a pure function. */ function cached(fn) { var cache = Object.create(null) return function cachedFn(str) { var hit = cache[str] return hit || (cache[str] = fn(str)) } } /** * Camelize a hyphen-delimited string. */ var camelizeRE = /-(\w)/g var camelize = cached(function(str) { return str.replace(camelizeRE, function(_, c) { return c ? c.toUpperCase() : "" }) }) /** * Capitalize a string. */ var capitalize = cached(function(str) { return str.charAt(0).toUpperCase() + str.slice(1) }) /** * Hyphenate a camelCase string. */ var hyphenateRE = /([^-])([A-Z])/g var hyphenate = cached(function(str) { return str .replace(hyphenateRE, "$1-$2") .replace(hyphenateRE, "$1-$2") .toLowerCase() }) /** * Simple bind, faster than native */ function bind(fn, ctx) { function boundFn(a) { var l = arguments.length return l ? (l > 1 ? fn.apply(ctx, arguments) : fn.call(ctx, a)) : fn.call(ctx) } // record original fn length boundFn._length = fn.length return boundFn } /** * Convert an Array-like object to a real Array. */ function toArray(list, start) { start = start || 0 var i = list.length - start var ret = new Array(i) while (i--) { ret[i] = list[i + start] } return ret } /** * Mix properties into target object. */ function extend(to, _from) { for (var key in _from) { to[key] = _from[key] } return to } /** * Merge an Array of Objects into a single Object. */ function toObject(arr) { var res = {} for (var i = 0; i < arr.length; i++) { if (arr[i]) { extend(res, arr[i]) } } return res } /** * Perform no operation. * Stubbing args to make Flow happy without leaving useless transpiled code * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/) */ function noop(a, b, c) {} /** * Always return false. */ var no = function(a, b, c) { return false } /** * Return same value */ var identity = function(_) { return _ } /** * Generate a static keys string from compiler modules. */ /** * Check if two values are loosely equal - that is, * if they are plain objects, do they have the same shape? */ function looseEqual(a, b) { var isObjectA = isObject(a) var isObjectB = isObject(b) if (isObjectA && isObjectB) { try { return JSON.stringify(a) === JSON.stringify(b) } catch (e) { // possible circular reference return a === b } } else if (!isObjectA && !isObjectB) { return String(a) === String(b) } else { return false } } function looseIndexOf(arr, val) { for (var i = 0; i < arr.length; i++) { if (looseEqual(arr[i], val)) { return i } } return -1 } /** * Ensure a function is called only once. */ function once(fn) { var called = false return function() { if (!called) { called = true fn.apply(this, arguments) } } } var SSR_ATTR = "data-server-rendered" var ASSET_TYPES = ["component", "directive", "filter"] var LIFECYCLE_HOOKS = [ "beforeCreate", "created", "beforeMount", "mounted", "beforeUpdate", "updated", "beforeDestroy", "destroyed", "activated", "deactivated", "onLaunch", "onLoad", "onShow", "onReady", "onHide", "onUnload", "onPullDownRefresh", "onReachBottom", "onShareAppMessage", "onPageScroll", "onTabItemTap", "attached", "ready", "moved", "detached", "onUniNViewMessage", //fixed by xxxxxx "onNavigationBarButtonTap", //fixed by xxxxxx "onBackPress",//fixed by xxxxxx ] /* */ var config = { /** * Option merge strategies (used in core/util/options) */ optionMergeStrategies: Object.create(null), /** * Whether to suppress warnings. */ silent: false, /** * Show production mode tip message on boot? */ productionTip: "production" !== "production", /** * Whether to enable devtools */ devtools: "production" !== "production", /** * Whether to record perf */ performance: false, /** * Error handler for watcher errors */ errorHandler: null, /** * Warn handler for watcher warns */ warnHandler: null, /** * Ignore certain custom elements */ ignoredElements: [], /** * Custom user key aliases for v-on */ keyCodes: Object.create(null), /** * Check if a tag is reserved so that it cannot be registered as a * component. This is platform-dependent and may be overwritten. */ isReservedTag: no, /** * Check if an attribute is reserved so that it cannot be used as a component * prop. This is platform-dependent and may be overwritten. */ isReservedAttr: no, /** * Check if a tag is an unknown element. * Platform-dependent. */ isUnknownElement: no, /** * Get the namespace of an element */ getTagNamespace: noop, /** * Parse the real tag name for the specific platform. */ parsePlatformTagName: identity, /** * Check if an attribute must be bound using property, e.g. value * Platform-dependent. */ mustUseProp: no, /** * Exposed for legacy reasons */ _lifecycleHooks: LIFECYCLE_HOOKS } /* */ var emptyObject = Object.freeze({}) /** * Check if a string starts with $ or _ */ function isReserved(str) { var c = (str + "").charCodeAt(0) return c === 0x24 || c === 0x5f } /** * Define a property. */ function def(obj, key, val, enumerable) { Object.defineProperty(obj, key, { value: val, enumerable: !!enumerable, writable: true, configurable: true }) } /** * Parse simple path. */ var bailRE = /[^\w.$]/ function parsePath(path) { if (bailRE.test(path)) { return } var segments = path.split(".") return function(obj) { for (var i = 0; i < segments.length; i++) { if (!obj) { return } obj = obj[segments[i]] } return obj } } /* */ var warn = noop var formatComponentName = null // work around flow check /* */ function handleError(err, vm, info) { if (config.errorHandler) { config.errorHandler.call(null, err, vm, info) } else { if (inBrowser && typeof console !== "undefined") { console.error(err) } else { throw err } } } /* */ // can we use __proto__? var hasProto = "__proto__" in {} // Browser environment sniffing var inBrowser = typeof window !== "undefined" var UA = ["mpvue-runtime"].join() var isIE = UA && /msie|trident/.test(UA) var isIE9 = UA && UA.indexOf("msie 9.0") > 0 var isEdge = UA && UA.indexOf("edge/") > 0 var isAndroid = UA && UA.indexOf("android") > 0 var isIOS = UA && /iphone|ipad|ipod|ios/.test(UA) var isChrome = UA && /chrome\/\d+/.test(UA) && !isEdge // Firefix has a "watch" function on Object.prototype... var nativeWatch = {}.watch var supportsPassive = false if (inBrowser) { try { var opts = {} Object.defineProperty(opts, "passive", { get: function get() { /* istanbul ignore next */ supportsPassive = true } }) // https://github.com/facebook/flow/issues/285 window.addEventListener("test-passive", null, opts) } catch (e) {} } // this needs to be lazy-evaled because vue may be required before // vue-server-renderer can set VUE_ENV var _isServer var isServerRendering = function() { if (_isServer === undefined) { /* istanbul ignore if */ if (!inBrowser && typeof global !== "undefined") { // detect presence of vue-server-renderer and avoid // Webpack shimming the process _isServer = global["process"].env.VUE_ENV === "server" } else { _isServer = false } } return _isServer } // detect devtools var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__ /* istanbul ignore next */ function isNative(Ctor) { return typeof Ctor === "function" && /native code/.test(Ctor.toString()) } var hasSymbol = typeof Symbol !== "undefined" && isNative(Symbol) && typeof Reflect !== "undefined" && isNative(Reflect.ownKeys) /** * Defer a task to execute it asynchronously. */ var nextTick = (function() { var callbacks = [] var pending = false var timerFunc function nextTickHandler() { pending = false var copies = callbacks.slice(0) callbacks.length = 0 for (var i = 0; i < copies.length; i++) { copies[i]() } } // the nextTick behavior leverages the microtask queue, which can be accessed // via either native Promise.then or MutationObserver. // MutationObserver has wider support, however it is seriously bugged in // UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It // completely stops working after triggering a few times... so, if native // Promise is available, we will use it: /* istanbul ignore if */ if (typeof Promise !== "undefined" && isNative(Promise)) { var p = Promise.resolve() var logError = function(err) { console.error(err) } timerFunc = function() { p.then(nextTickHandler).catch(logError) // in problematic UIWebViews, Promise.then doesn't completely break, but // it can get stuck in a weird state where callbacks are pushed into the // microtask queue but the queue isn't being flushed, until the browser // needs to do some other work, e.g. handle a timer. Therefore we can // "force" the microtask queue to be flushed by adding an empty timer. if (isIOS) { setTimeout(noop) } } // } else if (typeof MutationObserver !== 'undefined' && ( // isNative(MutationObserver) || // // PhantomJS and iOS 7.x // MutationObserver.toString() === '[object MutationObserverConstructor]' // )) { // // use MutationObserver where native Promise is not available, // // e.g. PhantomJS IE11, iOS7, Android 4.4 // var counter = 1 // var observer = new MutationObserver(nextTickHandler) // var textNode = document.createTextNode(String(counter)) // observer.observe(textNode, { // characterData: true // }) // timerFunc = () => { // counter = (counter + 1) % 2 // textNode.data = String(counter) // } } else { // fallback to setTimeout /* istanbul ignore next */ timerFunc = function() { setTimeout(nextTickHandler, 0) } } return function queueNextTick(cb, ctx) { var _resolve callbacks.push(function() { if (cb) { try { cb.call(ctx) } catch (e) { handleError(e, ctx, "nextTick") } } else if (_resolve) { _resolve(ctx) } }) if (!pending) { pending = true timerFunc() } if (!cb && typeof Promise !== "undefined") { return new Promise(function(resolve, reject) { _resolve = resolve }) } } })() var _Set /* istanbul ignore if */ if (typeof Set !== "undefined" && isNative(Set)) { // use native Set when available. _Set = Set } else { // a non-standard Set polyfill that only works with primitive keys. _Set = (function() { function Set() { this.set = Object.create(null) } Set.prototype.has = function has(key) { return this.set[key] === true } Set.prototype.add = function add(key) { this.set[key] = true } Set.prototype.clear = function clear() { this.set = Object.create(null) } return Set })() } /* */ var uid$1 = 0 /** * A dep is an observable that can have multiple * directives subscribing to it. */ var Dep = function Dep() { this.id = uid$1++ this.subs = [] } Dep.prototype.addSub = function addSub(sub) { this.subs.push(sub) } Dep.prototype.removeSub = function removeSub(sub) { remove(this.subs, sub) } Dep.prototype.depend = function depend() { if (Dep.target) { Dep.target.addDep(this) } } Dep.prototype.notify = function notify() { // stabilize the subscriber list first var subs = this.subs.slice() for (var i = 0, l = subs.length; i < l; i++) { subs[i].update() } } // the current target watcher being evaluated. // this is globally unique because there could be only one // watcher being evaluated at any time. Dep.target = null var targetStack = [] function pushTarget(_target) { if (Dep.target) { targetStack.push(Dep.target) } Dep.target = _target } function popTarget() { Dep.target = targetStack.pop() } /* * not type checking this file because flow doesn't play well with * dynamically accessing methods on Array prototype */ var arrayProto = Array.prototype var arrayMethods = Object.create(arrayProto) ;["push", "pop", "shift", "unshift", "splice", "sort", "reverse"].forEach(function(method) { // cache original method var original = arrayProto[method] def(arrayMethods, method, function mutator() { var args = [], len = arguments.length while (len--) args[len] = arguments[len] var result = original.apply(this, args) var ob = this.__ob__ var inserted switch (method) { case "push": case "unshift": inserted = args break case "splice": inserted = args.slice(2) break } if (inserted) { ob.observeArray(inserted) } // notify change ob.dep.notify() return result }) }) /* */ var arrayKeys = Object.getOwnPropertyNames(arrayMethods) /** * By default, when a reactive property is set, the new value is * also converted to become reactive. However when passing down props, * we don't want to force conversion because the value may be a nested value * under a frozen data structure. Converting it would defeat the optimization. */ var observerState = { shouldConvert: true } /** * Observer class that are attached to each observed * object. Once attached, the observer converts target * object's property keys into getter/setters that * collect dependencies and dispatches updates. */ var Observer = function Observer(value) { this.value = value this.dep = new Dep() this.vmCount = 0 def(value, "__ob__", this) if (Array.isArray(value)) { var augment = hasProto ? protoAugment : copyAugment augment(value, arrayMethods, arrayKeys) this.observeArray(value) } else { this.walk(value) } } /** * Walk through each property and convert them into * getter/setters. This method should only be called when * value type is Object. */ Observer.prototype.walk = function walk(obj) { var keys = Object.keys(obj) for (var i = 0; i < keys.length; i++) { defineReactive$$1(obj, keys[i], obj[keys[i]]) } } /** * Observe a list of Array items. */ Observer.prototype.observeArray = function observeArray(items) { for (var i = 0, l = items.length; i < l; i++) { observe(items[i]) } } // helpers /** * Augment an target Object or Array by intercepting * the prototype chain using __proto__ */ function protoAugment(target, src, keys) { /* eslint-disable no-proto */ target.__proto__ = src /* eslint-enable no-proto */ } /** * Augment an target Object or Array by defining * hidden properties. */ /* istanbul ignore next */ function copyAugment(target, src, keys) { for (var i = 0, l = keys.length; i < l; i++) { var key = keys[i] def(target, key, src[key]) } } /** * Attempt to create an observer instance for a value, * returns the new observer if successfully observed, * or the existing observer if the value already has one. */ function observe(value, asRootData) { if (!isObject(value)) { return } var ob if (hasOwn(value, "__ob__") && value.__ob__ instanceof Observer) { ob = value.__ob__ } else if ( observerState.shouldConvert && !isServerRendering() && (Array.isArray(value) || isPlainObject(value)) && Object.isExtensible(value) && !value._isVue ) { ob = new Observer(value) } if (asRootData && ob) { ob.vmCount++ } return ob } /** * Define a reactive property on an Object. */ function defineReactive$$1(obj, key, val, customSetter, shallow) { var dep = new Dep() var property = Object.getOwnPropertyDescriptor(obj, key) if (property && property.configurable === false) { return } // cater for pre-defined getter/setters var getter = property && property.get var setter = property && property.set var childOb = !shallow && observe(val) Object.defineProperty(obj, key, { enumerable: true, configurable: true, get: function reactiveGetter() { var value = getter ? getter.call(obj) : val if (Dep.target) { dep.depend() if (childOb) { childOb.dep.depend() } if (Array.isArray(value)) { dependArray(value) } } return value }, set: function reactiveSetter(newVal) { var value = getter ? getter.call(obj) : val /* eslint-disable no-self-compare */ if (newVal === value || (newVal !== newVal && value !== value)) { return } /* eslint-enable no-self-compare */ if ("production" !== "production" && customSetter) { customSetter() } if (setter) { setter.call(obj, newVal) } else { val = newVal } childOb = !shallow && observe(newVal) dep.notify() } }) } /** * Set a property on an object. Adds the new property and * triggers change notification if the property doesn't * already exist. */ function set(target, key, val) { if (Array.isArray(target) && isValidArrayIndex(key)) { target.length = Math.max(target.length, key) target.splice(key, 1, val) return val } if (hasOwn(target, key)) { target[key] = val return val } var ob = target.__ob__ if (target._isVue || (ob && ob.vmCount)) { "production" !== "production" && warn( "Avoid adding reactive properties to a Vue instance or its root $data " + "at runtime - declare it upfront in the data option." ) return val } if (!ob) { target[key] = val return val } defineReactive$$1(ob.value, key, val) ob.dep.notify() return val } /** * Delete a property and trigger change if necessary. */ function del(target, key) { if (Array.isArray(target) && isValidArrayIndex(key)) { target.splice(key, 1) return } var ob = target.__ob__ if (target._isVue || (ob && ob.vmCount)) { "production" !== "production" && warn( "Avoid deleting properties on a Vue instance or its root $data " + "- just set it to null." ) return } if (!hasOwn(target, key)) { return } delete target[key] if (!ob) { return } ob.dep.notify() } /** * Collect dependencies on array elements when the array is touched, since * we cannot intercept array element access like property getters. */ function dependArray(value) { for (var e = void 0, i = 0, l = value.length; i < l; i++) { e = value[i] e && e.__ob__ && e.__ob__.dep.depend() if (Array.isArray(e)) { dependArray(e) } } } /* */ /** * Option overwriting strategies are functions that handle * how to merge a parent option value and a child option * value into the final value. */ var strats = config.optionMergeStrategies /** * Options with restrictions */ /** * Helper that recursively merges two data objects together. */ function mergeData(to, from) { if (!from) { return to } var key, toVal, fromVal var keys = Object.keys(from) for (var i = 0; i < keys.length; i++) { key = keys[i] toVal = to[key] fromVal = from[key] if (!hasOwn(to, key)) { set(to, key, fromVal) } else if (isPlainObject(toVal) && isPlainObject(fromVal)) { mergeData(toVal, fromVal) } } return to } /** * Data */ function mergeDataOrFn(parentVal, childVal, vm) { if (!vm) { // in a Vue.extend merge, both should be functions if (!childVal) { return parentVal } if (!parentVal) { return childVal } // when parentVal & childVal are both present, // we need to return a function that returns the // merged result of both functions... no need to // check if parentVal is a function here because // it has to be a function to pass previous merges. return function mergedDataFn() { return mergeData( typeof childVal === "function" ? childVal.call(this) : childVal, parentVal.call(this) ) } } else if (parentVal || childVal) { return function mergedInstanceDataFn() { // instance merge var instanceData = typeof childVal === "function" ? childVal.call(vm) : childVal var defaultData = typeof parentVal === "function" ? parentVal.call(vm) : undefined if (instanceData) { return mergeData(instanceData, defaultData) } else { return defaultData } } } } strats.data = function(parentVal, childVal, vm) { if (!vm) { if (childVal && typeof childVal !== "function") { "production" !== "production" && warn( 'The "data" option should be a function ' + "that returns a per-instance value in component " + "definitions.", vm ) return parentVal } return mergeDataOrFn.call(this, parentVal, childVal) } return mergeDataOrFn(parentVal, childVal, vm) } /** * Hooks and props are merged as arrays. */ function mergeHook(parentVal, childVal) { return childVal ? parentVal ? parentVal.concat(childVal) : Array.isArray(childVal) ? childVal : [childVal] : parentVal } LIFECYCLE_HOOKS.forEach(function(hook) { strats[hook] = mergeHook }) /** * Assets * * When a vm is present (instance creation), we need to do * a three-way merge between constructor options, instance * options and parent options. */ function mergeAssets(parentVal, childVal) { var res = Object.create(parentVal || null) return childVal ? extend(res, childVal) : res } ASSET_TYPES.forEach(function(type) { strats[type + "s"] = mergeAssets }) /** * Watchers. * * Watchers hashes should not overwrite one * another, so we merge them as arrays. */ strats.watch = function(parentVal, childVal) { // work around Firefox's Object.prototype.watch... if (parentVal === nativeWatch) { parentVal = undefined } if (childVal === nativeWatch) { childVal = undefined } /* istanbul ignore if */ if (!childVal) { return Object.create(parentVal || null) } if (!parentVal) { return childVal } var ret = {} extend(ret, parentVal) for (var key in childVal) { var parent = ret[key] var child = childVal[key] if (parent && !Array.isArray(parent)) { parent = [parent] } ret[key] = parent ? parent.concat(child) : Array.isArray(child) ? child : [child] } return ret } /** * Other object hashes. */ strats.props = strats.methods = strats.inject = strats.computed = function( parentVal, childVal ) { if (!childVal) { return Object.create(parentVal || null) } if (!parentVal) { return childVal } var ret = Object.create(null) extend(ret, parentVal) extend(ret, childVal) return ret } strats.provide = mergeDataOrFn /** * Default strategy. */ var defaultStrat = function(parentVal, childVal) { return childVal === undefined ? parentVal : childVal } /** * Ensure all props option syntax are normalized into the * Object-based format. */ function normalizeProps(options) { var props = options.props if (!props) { return } var res = {} var i, val, name if (Array.isArray(props)) { i = props.length while (i--) { val = props[i] if (typeof val === "string") { name = camelize(val) res[name] = { type: null } } else { } } } else if (isPlainObject(props)) { for (var key in props) { val = props[key] name = camelize(key) res[name] = isPlainObject(val) ? val : { type: val } } } options.props = res } /** * Normalize all injections into Object-based format */ function normalizeInject(options) { var inject = options.inject if (Array.isArray(inject)) { var normalized = (options.inject = {}) for (var i = 0; i < inject.length; i++) { normalized[inject[i]] = inject[i] } } } /** * Normalize raw function directives into object format. */ function normalizeDirectives(options) { var dirs = options.directives if (dirs) { for (var key in dirs) { var def = dirs[key] if (typeof def === "function") { dirs[key] = { bind: def, update: def } } } } } /** * Merge two option objects into a new one. * Core utility used in both instantiation and inheritance. */ function mergeOptions(parent, child, vm) { if (typeof child === "function") { child = child.options } normalizeProps(child) normalizeInject(child) normalizeDirectives(child) var extendsFrom = child.extends if (extendsFrom) { parent = mergeOptions(parent, extendsFrom, vm) } if (child.mixins) { for (var i = 0, l = child.mixins.length; i < l; i++) { parent = mergeOptions(parent, child.mixins[i], vm) } } var options = {} var key for (key in parent) { mergeField(key) } for (key in child) { if (!hasOwn(parent, key)) { mergeField(key) } } function mergeField(key) { var strat = strats[key] || defaultStrat options[key] = strat(parent[key], child[key], vm, key) } return options } /** * Resolve an asset. * This function is used because child instances need access * to assets defined in its ancestor chain. */ function resolveAsset(options, type, id, warnMissing) { /* istanbul ignore if */ if (typeof id !== "string") { return } var assets = options[type] // check local registration variations first if (hasOwn(assets, id)) { return assets[id] } var camelizedId = camelize(id) if (hasOwn(assets, camelizedId)) { return assets[camelizedId] } var PascalCaseId = capitalize(camelizedId) if (hasOwn(assets, PascalCaseId)) { return assets[PascalCaseId] } // fallback to prototype chain var res = assets[id] || assets[camelizedId] || assets[PascalCaseId] if ("production" !== "production" && warnMissing && !res) { warn("Failed to resolve " + type.slice(0, -1) + ": " + id, options) } return res } /* */ function validateProp(key, propOptions, propsData, vm) { var prop = propOptions[key] var absent = !hasOwn(propsData, key) var value = propsData[key] // handle boolean props if (isType(Boolean, prop.type)) { if (absent && !hasOwn(prop, "default")) { value = false } else if (!isType(String, prop.type) && (value === "" || value === hyphenate(key))) { value = true } } // check default value if (value === undefined) { value = getPropDefaultValue(vm, prop, key) // since the default value is a fresh copy, // make sure to observe it. var prevShouldConvert = observerState.shouldConvert observerState.shouldConvert = true observe(value) observerState.shouldConvert = prevShouldConvert } return value } /** * Get the default value of a prop. */ function getPropDefaultValue(vm, prop, key) { // no default, return undefined if (!hasOwn(prop, "default")) { return undefined } var def = prop.default // warn against non-factory defaults for Object & Array if ("production" !== "production" && isObject(def)) { warn( 'Invalid default value for prop "' + key + '": ' + "Props with type Object/Array must use a factory function " + "to return the default value.", vm ) } // the raw prop value was also undefined from previous render, // return previous default value to avoid unnecessary watcher trigger if ( vm && vm.$options.propsData && vm.$options.propsData[key] === undefined && vm._props[key] !== undefined ) { return vm._props[key] } // call factory function for non-Function types // a value is Function if its prototype is function even across different execution context return typeof def === "function" && getType(prop.type) !== "Function" ? def.call(vm) : def } /** * Use function string name to check built-in types, * because a simple equality check will fail when running * across different vms / iframes. */ function getType(fn) { var match = fn && fn.toString().match(/^\s*function (\w+)/) return match ? match[1] : "" } function isType(type, fn) { if (!Array.isArray(fn)) { return getType(fn) === getType(type) } for (var i = 0, len = fn.length; i < len; i++) { if (getType(fn[i]) === getType(type)) { return true } } /* istanbul ignore next */ return false } /* */ /* not type checking this file because flow doesn't play well with Proxy */ var mark var measure /* */ var VNode = function VNode( tag, data, children, text, elm, context, componentOptions, asyncFactory ) { this.tag = tag this.data = data this.children = children this.text = text this.elm = elm this.ns = undefined this.context = context this.functionalContext = undefined this.key = data && data.key this.componentOptions = componentOptions this.componentInstance = undefined this.parent = undefined this.raw = false this.isStatic = false this.isRootInsert = true this.isComment = false this.isCloned = false this.isOnce = false this.asyncFactory = asyncFactory this.asyncMeta = undefined this.isAsyncPlaceholder = false } var prototypeAccessors = { child: {} } // DEPRECATED: alias for componentInstance for backwards compat. /* istanbul ignore next */ prototypeAccessors.child.get = function() { return this.componentInstance } Object.defineProperties(VNode.prototype, prototypeAccessors) var createEmptyVNode = function(text) { if (text === void 0) text = "" var node = new VNode() node.text = text node.isComment = true return node } function createTextVNode(val) { return new VNode(undefined, undefined, undefined, String(val)) } // optimized shallow clone // used for static nodes and slot nodes because they may be reused across // multiple renders, cloning them avoids errors when DOM manipulations rely // on their elm reference. function cloneVNode(vnode) { var cloned = new VNode( vnode.tag, vnode.data, vnode.children, vnode.text, vnode.elm, vnode.context, vnode.componentOptions, vnode.asyncFactory ) cloned.ns = vnode.ns cloned.isStatic = vnode.isStatic cloned.key = vnode.key cloned.isComment = vnode.isComment cloned.isCloned = true return cloned } function cloneVNodes(vnodes) { var len = vnodes.length var res = new Array(len) for (var i = 0; i < len; i++) { res[i] = cloneVNode(vnodes[i]) } return res } /* */ var normalizeEvent = cached(function(name) { var passive = name.charAt(0) === "&" name = passive ? name.slice(1) : name var once$$1 = name.charAt(0) === "~" // Prefixed last, checked first name = once$$1 ? name.slice(1) : name var capture = name.charAt(0) === "!" name = capture ? name.slice(1) : name return { name: name, once: once$$1, capture: capture, passive: passive } }) function createFnInvoker(fns) { function invoker() { var arguments$1 = arguments var fns = invoker.fns if (Array.isArray(fns)) { var cloned = fns.slice() for (var i = 0; i < cloned.length; i++) { cloned[i].apply(null, arguments$1) } } else { // return handler return value for single handlers return fns.apply(null, arguments) } } invoker.fns = fns return invoker } function updateListeners(on, oldOn, add, remove$$1, vm) { var name, cur, old, event for (name in on) { cur = on[name] old = oldOn[name] event = normalizeEvent(name) if (isUndef(cur)) { "production" !== "production" && warn('Invalid handler for event "' + event.name + '": got ' + String(cur), vm) } else if (isUndef(old)) { if (isUndef(cur.fns)) { cur = on[name] = createFnInvoker(cur) } add(event.name, cur, event.once, event.capture, event.passive) } else if (cur !== old) { old.fns = cur on[name] = old } } for (name in oldOn) { if (isUndef(on[name])) { event = normalizeEvent(name) remove$$1(event.name, oldOn[name], event.capture) } } } /* */ /* */ function extractPropsFromVNodeData(data, Ctor, tag) { // we are only extracting raw values here. // validation and default values are handled in the child // component itself. var propOptions = Ctor.options.props if (isUndef(propOptions)) { return } var res = {} var attrs = data.attrs var props = data.props if (isDef(attrs) || isDef(props)) { for (var key in propOptions) { var altKey = hyphenate(key) checkProp(res, props, key, altKey, true) || checkProp(res, attrs, key, altKey, false) } } return res } function checkProp(res, hash, key, altKey, preserve) { if (isDef(hash)) { if (hasOwn(hash, key)) { res[key] = hash[key] if (!preserve) { delete hash[key] } return true } else if (hasOwn(hash, altKey)) { res[key] = hash[altKey] if (!preserve) { delete hash[altKey] } return true } } return false } /* */ // The template compiler attempts to minimize the need for normalization by // statically analyzing the template at compile time. // // For plain HTML markup, normalization can be completely skipped because the // generated render function is guaranteed to return Array. There are // two cases where extra normalization is needed: // 1. When the children contains components - because a functional component // may return an Array instead of a single root. In this case, just a simple // normalization is needed - if any child is an Array, we flatten the whole // thing with Array.prototype.concat. It is guaranteed to be only 1-level deep // because functional components already normalize their own children. function simpleNormalizeChildren(children) { for (var i = 0; i < children.length; i++) { if (Array.isArray(children[i])) { return Array.prototype.concat.apply([], children) } } return children } // 2. When the children contains constructs that always generated nested Arrays, // e.g.