, or missing
. Bailing hydration and performing ' + + 'full client-side render.' + ); + } + } + // either not server-rendered, or hydration failed. + // create an empty node and replace it + oldVnode = emptyNodeAt(oldVnode); + } + // replacing existing element + var oldElm = oldVnode.elm; + var parentElm$1 = nodeOps.parentNode(oldElm); + createElm( + vnode, + insertedVnodeQueue, + // extremely rare edge case: do not insert if old element is in a + // leaving transition. Only happens when combining transition + + // keep-alive + HOCs. (#4590) + oldElm._leaveCb ? null : parentElm$1, + nodeOps.nextSibling(oldElm) + ); + + if (isDef(vnode.parent)) { + // component root element replaced. + // update parent placeholder node element, recursively + var ancestor = vnode.parent; + while (ancestor) { + ancestor.elm = vnode.elm; + ancestor = ancestor.parent; + } + if (isPatchable(vnode)) { + for (var i = 0; i < cbs.create.length; ++i) { + cbs.create[i](emptyNode, vnode.parent); + } + } + } + + if (isDef(parentElm$1)) { + removeVnodes(parentElm$1, [oldVnode], 0, 0); + } else if (isDef(oldVnode.tag)) { + invokeDestroyHook(oldVnode); + } + } + } + + invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch); + return vnode.elm + } +} + +/* */ + +var directives = { + create: updateDirectives, + update: updateDirectives, + destroy: function unbindDirectives (vnode) { + updateDirectives(vnode, emptyNode); + } +}; + +function updateDirectives (oldVnode, vnode) { + if (oldVnode.data.directives || vnode.data.directives) { + _update(oldVnode, vnode); + } +} + +function _update (oldVnode, vnode) { + var isCreate = oldVnode === emptyNode; + var isDestroy = vnode === emptyNode; + var oldDirs = normalizeDirectives$1(oldVnode.data.directives, oldVnode.context); + var newDirs = normalizeDirectives$1(vnode.data.directives, vnode.context); + + var dirsWithInsert = []; + var dirsWithPostpatch = []; + + var key, oldDir, dir; + for (key in newDirs) { + oldDir = oldDirs[key]; + dir = newDirs[key]; + if (!oldDir) { + // new directive, bind + callHook$1(dir, 'bind', vnode, oldVnode); + if (dir.def && dir.def.inserted) { + dirsWithInsert.push(dir); + } + } else { + // existing directive, update + dir.oldValue = oldDir.value; + callHook$1(dir, 'update', vnode, oldVnode); + if (dir.def && dir.def.componentUpdated) { + dirsWithPostpatch.push(dir); + } + } + } + + if (dirsWithInsert.length) { + var callInsert = function () { + for (var i = 0; i < dirsWithInsert.length; i++) { + callHook$1(dirsWithInsert[i], 'inserted', vnode, oldVnode); + } + }; + if (isCreate) { + mergeVNodeHook(vnode.data.hook || (vnode.data.hook = {}), 'insert', callInsert); + } else { + callInsert(); + } + } + + if (dirsWithPostpatch.length) { + mergeVNodeHook(vnode.data.hook || (vnode.data.hook = {}), 'postpatch', function () { + for (var i = 0; i < dirsWithPostpatch.length; i++) { + callHook$1(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode); + } + }); + } + + if (!isCreate) { + for (key in oldDirs) { + if (!newDirs[key]) { + // no longer present, unbind + callHook$1(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy); + } + } + } +} + +var emptyModifiers = Object.create(null); + +function normalizeDirectives$1 ( + dirs, + vm +) { + var res = Object.create(null); + if (!dirs) { + return res + } + var i, dir; + for (i = 0; i < dirs.length; i++) { + dir = dirs[i]; + if (!dir.modifiers) { + dir.modifiers = emptyModifiers; + } + res[getRawDirName(dir)] = dir; + dir.def = resolveAsset(vm.$options, 'directives', dir.name, true); + } + return res +} + +function getRawDirName (dir) { + return dir.rawName || ((dir.name) + "." + (Object.keys(dir.modifiers || {}).join('.'))) +} + +function callHook$1 (dir, hook, vnode, oldVnode, isDestroy) { + var fn = dir.def && dir.def[hook]; + if (fn) { + fn(vnode.elm, dir, vnode, oldVnode, isDestroy); + } +} + +var baseModules = [ + ref, + directives +]; + +/* */ + +function updateAttrs (oldVnode, vnode) { + if (!oldVnode.data.attrs && !vnode.data.attrs) { + return + } + var key, cur, old; + var elm = vnode.elm; + var oldAttrs = oldVnode.data.attrs || {}; + var attrs = vnode.data.attrs || {}; + // clone observed objects, as the user probably wants to mutate it + if (attrs.__ob__) { + attrs = vnode.data.attrs = extend({}, attrs); + } + + for (key in attrs) { + cur = attrs[key]; + old = oldAttrs[key]; + if (old !== cur) { + setAttr(elm, key, cur); + } + } + // #4391: in IE9, setting type can reset value for input[type=radio] + /* istanbul ignore if */ + if (isIE9 && attrs.value !== oldAttrs.value) { + setAttr(elm, 'value', attrs.value); + } + for (key in oldAttrs) { + if (attrs[key] == null) { + if (isXlink(key)) { + elm.removeAttributeNS(xlinkNS, getXlinkProp(key)); + } else if (!isEnumeratedAttr(key)) { + elm.removeAttribute(key); + } + } + } +} + +function setAttr (el, key, value) { + if (isBooleanAttr(key)) { + // set attribute for blank value + // e.g. + if (isFalsyAttrValue(value)) { + el.removeAttribute(key); + } else { + el.setAttribute(key, key); + } + } else if (isEnumeratedAttr(key)) { + el.setAttribute(key, isFalsyAttrValue(value) || value === 'false' ? 'false' : 'true'); + } else if (isXlink(key)) { + if (isFalsyAttrValue(value)) { + el.removeAttributeNS(xlinkNS, getXlinkProp(key)); + } else { + el.setAttributeNS(xlinkNS, key, value); + } + } else { + if (isFalsyAttrValue(value)) { + el.removeAttribute(key); + } else { + el.setAttribute(key, value); + } + } +} + +var attrs = { + create: updateAttrs, + update: updateAttrs +}; + +/* */ + +function updateClass (oldVnode, vnode) { + var el = vnode.elm; + var data = vnode.data; + var oldData = oldVnode.data; + if (!data.staticClass && !data.class && + (!oldData || (!oldData.staticClass && !oldData.class))) { + return + } + + var cls = genClassForVnode(vnode); + + // handle transition classes + var transitionClass = el._transitionClasses; + if (transitionClass) { + cls = concat(cls, stringifyClass(transitionClass)); + } + + // set the class + if (cls !== el._prevClass) { + el.setAttribute('class', cls); + el._prevClass = cls; + } +} + +var klass = { + create: updateClass, + update: updateClass +}; + +/* */ + +var validDivisionCharRE = /[\w).+\-_$\]]/; + +function parseFilters (exp) { + var inSingle = false; + var inDouble = false; + var inTemplateString = false; + var inRegex = false; + var curly = 0; + var square = 0; + var paren = 0; + var lastFilterIndex = 0; + var c, prev, i, expression, filters; + + for (i = 0; i < exp.length; i++) { + prev = c; + c = exp.charCodeAt(i); + if (inSingle) { + if (c === 0x27 && prev !== 0x5C) { inSingle = false; } + } else if (inDouble) { + if (c === 0x22 && prev !== 0x5C) { inDouble = false; } + } else if (inTemplateString) { + if (c === 0x60 && prev !== 0x5C) { inTemplateString = false; } + } else if (inRegex) { + if (c === 0x2f && prev !== 0x5C) { inRegex = false; } + } else if ( + c === 0x7C && // pipe + exp.charCodeAt(i + 1) !== 0x7C && + exp.charCodeAt(i - 1) !== 0x7C && + !curly && !square && !paren + ) { + if (expression === undefined) { + // first filter, end of expression + lastFilterIndex = i + 1; + expression = exp.slice(0, i).trim(); + } else { + pushFilter(); + } + } else { + switch (c) { + case 0x22: inDouble = true; break // " + case 0x27: inSingle = true; break // ' + case 0x60: inTemplateString = true; break // ` + case 0x28: paren++; break // ( + case 0x29: paren--; break // ) + case 0x5B: square++; break // [ + case 0x5D: square--; break // ] + case 0x7B: curly++; break // { + case 0x7D: curly--; break // } + } + if (c === 0x2f) { // / + var j = i - 1; + var p = (void 0); + // find first non-whitespace prev char + for (; j >= 0; j--) { + p = exp.charAt(j); + if (p !== ' ') { break } + } + if (!p || !validDivisionCharRE.test(p)) { + inRegex = true; + } + } + } + } + + if (expression === undefined) { + expression = exp.slice(0, i).trim(); + } else if (lastFilterIndex !== 0) { + pushFilter(); + } + + function pushFilter () { + (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim()); + lastFilterIndex = i + 1; + } + + if (filters) { + for (i = 0; i < filters.length; i++) { + expression = wrapFilter(expression, filters[i]); + } + } + + return expression +} + +function wrapFilter (exp, filter) { + var i = filter.indexOf('('); + if (i < 0) { + // _f: resolveFilter + return ("_f(\"" + filter + "\")(" + exp + ")") + } else { + var name = filter.slice(0, i); + var args = filter.slice(i + 1); + return ("_f(\"" + name + "\")(" + exp + "," + args) + } +} + +/* */ + +function baseWarn (msg) { + console.error(("[Vue compiler]: " + msg)); +} + +function pluckModuleFunction ( + modules, + key +) { + return modules + ? modules.map(function (m) { return m[key]; }).filter(function (_) { return _; }) + : [] +} + +function addProp (el, name, value) { + (el.props || (el.props = [])).push({ name: name, value: value }); +} + +function addAttr (el, name, value) { + (el.attrs || (el.attrs = [])).push({ name: name, value: value }); +} + +function addDirective ( + el, + name, + rawName, + value, + arg, + modifiers +) { + (el.directives || (el.directives = [])).push({ name: name, rawName: rawName, value: value, arg: arg, modifiers: modifiers }); +} + +function addHandler ( + el, + name, + value, + modifiers, + important +) { + // check capture modifier + if (modifiers && modifiers.capture) { + delete modifiers.capture; + name = '!' + name; // mark the event as captured + } + if (modifiers && modifiers.once) { + delete modifiers.once; + name = '~' + name; // mark the event as once + } + var events; + if (modifiers && modifiers.native) { + delete modifiers.native; + events = el.nativeEvents || (el.nativeEvents = {}); + } else { + events = el.events || (el.events = {}); + } + var newHandler = { value: value, modifiers: modifiers }; + var handlers = events[name]; + /* istanbul ignore if */ + if (Array.isArray(handlers)) { + important ? handlers.unshift(newHandler) : handlers.push(newHandler); + } else if (handlers) { + events[name] = important ? [newHandler, handlers] : [handlers, newHandler]; + } else { + events[name] = newHandler; + } +} + +function getBindingAttr ( + el, + name, + getStatic +) { + var dynamicValue = + getAndRemoveAttr(el, ':' + name) || + getAndRemoveAttr(el, 'v-bind:' + name); + if (dynamicValue != null) { + return parseFilters(dynamicValue) + } else if (getStatic !== false) { + var staticValue = getAndRemoveAttr(el, name); + if (staticValue != null) { + return JSON.stringify(staticValue) + } + } +} + +function getAndRemoveAttr (el, name) { + var val; + if ((val = el.attrsMap[name]) != null) { + var list = el.attrsList; + for (var i = 0, l = list.length; i < l; i++) { + if (list[i].name === name) { + list.splice(i, 1); + break + } + } + } + return val +} + +/* */ + +/** + * Cross-platform code generation for component v-model + */ +function genComponentModel ( + el, + value, + modifiers +) { + var ref = modifiers || {}; + var number = ref.number; + var trim = ref.trim; + + var baseValueExpression = '$$v'; + var valueExpression = baseValueExpression; + if (trim) { + valueExpression = + "(typeof " + baseValueExpression + " === 'string'" + + "? " + baseValueExpression + ".trim()" + + ": " + baseValueExpression + ")"; + } + if (number) { + valueExpression = "_n(" + valueExpression + ")"; + } + var assignment = genAssignmentCode(value, valueExpression); + + el.model = { + value: ("(" + value + ")"), + expression: ("\"" + value + "\""), + callback: ("function (" + baseValueExpression + ") {" + assignment + "}") + }; +} + +/** + * Cross-platform codegen helper for generating v-model value assignment code. + */ +function genAssignmentCode ( + value, + assignment +) { + var modelRs = parseModel(value); + if (modelRs.idx === null) { + return (value + "=" + assignment) + } else { + return "var $$exp = " + (modelRs.exp) + ", $$idx = " + (modelRs.idx) + ";" + + "if (!Array.isArray($$exp)){" + + value + "=" + assignment + "}" + + "else{$$exp.splice($$idx, 1, " + assignment + ")}" + } +} + +/** + * parse directive model to do the array update transform. a[idx] = val => $$a.splice($$idx, 1, val) + * + * for loop possible cases: + * + * - test + * - test[idx] + * - test[test1[idx]] + * - test["a"][idx] + * - xxx.test[a[a].test1[idx]] + * - test.xxx.a["asa"][test1[idx]] + * + */ + +var len; +var str; +var chr; +var index$1; +var expressionPos; +var expressionEndPos; + +function parseModel (val) { + str = val; + len = str.length; + index$1 = expressionPos = expressionEndPos = 0; + + if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) { + return { + exp: val, + idx: null + } + } + + while (!eof()) { + chr = next(); + /* istanbul ignore if */ + if (isStringStart(chr)) { + parseString(chr); + } else if (chr === 0x5B) { + parseBracket(chr); + } + } + + return { + exp: val.substring(0, expressionPos), + idx: val.substring(expressionPos + 1, expressionEndPos) + } +} + +function next () { + return str.charCodeAt(++index$1) +} + +function eof () { + return index$1 >= len +} + +function isStringStart (chr) { + return chr === 0x22 || chr === 0x27 +} + +function parseBracket (chr) { + var inBracket = 1; + expressionPos = index$1; + while (!eof()) { + chr = next(); + if (isStringStart(chr)) { + parseString(chr); + continue + } + if (chr === 0x5B) { inBracket++; } + if (chr === 0x5D) { inBracket--; } + if (inBracket === 0) { + expressionEndPos = index$1; + break + } + } +} + +function parseString (chr) { + var stringQuote = chr; + while (!eof()) { + chr = next(); + if (chr === stringQuote) { + break + } + } +} + +/* */ + +var warn$1; + +// in some cases, the event used has to be determined at runtime +// so we used some reserved tokens during compile. +var RANGE_TOKEN = '__r'; +var CHECKBOX_RADIO_TOKEN = '__c'; + +function model ( + el, + dir, + _warn +) { + warn$1 = _warn; + var value = dir.value; + var modifiers = dir.modifiers; + var tag = el.tag; + var type = el.attrsMap.type; + + { + var dynamicType = el.attrsMap['v-bind:type'] || el.attrsMap[':type']; + if (tag === 'input' && dynamicType) { + warn$1( + ":\n" + + "v-model does not support dynamic input types. Use v-if branches instead." + ); + } + // inputs with type="file" are read only and setting the input's + // value will throw an error. + if (tag === 'input' && type === 'file') { + warn$1( + "<" + (el.tag) + " v-model=\"" + value + "\" type=\"file\">:\n" + + "File inputs are read only. Use a v-on:change listener instead." + ); + } + } + + if (tag === 'select') { + genSelect(el, value, modifiers); + } else if (tag === 'input' && type === 'checkbox') { + genCheckboxModel(el, value, modifiers); + } else if (tag === 'input' && type === 'radio') { + genRadioModel(el, value, modifiers); + } else if (tag === 'input' || tag === 'textarea') { + genDefaultModel(el, value, modifiers); + } else if (!config.isReservedTag(tag)) { + genComponentModel(el, value, modifiers); + // component v-model doesn't need extra runtime + return false + } else { + warn$1( + "<" + (el.tag) + " v-model=\"" + value + "\">: " + + "v-model is not supported on this element type. " + + 'If you are working with contenteditable, it\'s recommended to ' + + 'wrap a library dedicated for that purpose inside a custom component.' + ); + } + + // ensure runtime directive metadata + return true +} + +function genCheckboxModel ( + el, + value, + modifiers +) { + var number = modifiers && modifiers.number; + var valueBinding = getBindingAttr(el, 'value') || 'null'; + var trueValueBinding = getBindingAttr(el, 'true-value') || 'true'; + var falseValueBinding = getBindingAttr(el, 'false-value') || 'false'; + addProp(el, 'checked', + "Array.isArray(" + value + ")" + + "?_i(" + value + "," + valueBinding + ")>-1" + ( + trueValueBinding === 'true' + ? (":(" + value + ")") + : (":_q(" + value + "," + trueValueBinding + ")") + ) + ); + addHandler(el, CHECKBOX_RADIO_TOKEN, + "var $$a=" + value + "," + + '$$el=$event.target,' + + "$$c=$$el.checked?(" + trueValueBinding + "):(" + falseValueBinding + ");" + + 'if(Array.isArray($$a)){' + + "var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + "," + + '$$i=_i($$a,$$v);' + + "if($$c){$$i<0&&(" + value + "=$$a.concat($$v))}" + + "else{$$i>-1&&(" + value + "=$$a.slice(0,$$i).concat($$a.slice($$i+1)))}" + + "}else{" + value + "=$$c}", + null, true + ); +} + +function genRadioModel ( + el, + value, + modifiers +) { + var number = modifiers && modifiers.number; + var valueBinding = getBindingAttr(el, 'value') || 'null'; + valueBinding = number ? ("_n(" + valueBinding + ")") : valueBinding; + addProp(el, 'checked', ("_q(" + value + "," + valueBinding + ")")); + addHandler(el, CHECKBOX_RADIO_TOKEN, genAssignmentCode(value, valueBinding), null, true); +} + +function genSelect ( + el, + value, + modifiers +) { + var number = modifiers && modifiers.number; + var selectedVal = "Array.prototype.filter" + + ".call($event.target.options,function(o){return o.selected})" + + ".map(function(o){var val = \"_value\" in o ? o._value : o.value;" + + "return " + (number ? '_n(val)' : 'val') + "})"; + + var assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]'; + var code = "var $$selectedVal = " + selectedVal + ";"; + code = code + " " + (genAssignmentCode(value, assignment)); + addHandler(el, 'change', code, null, true); +} + +function genDefaultModel ( + el, + value, + modifiers +) { + var type = el.attrsMap.type; + var ref = modifiers || {}; + var lazy = ref.lazy; + var number = ref.number; + var trim = ref.trim; + var needCompositionGuard = !lazy && type !== 'range'; + var event = lazy + ? 'change' + : type === 'range' + ? RANGE_TOKEN + : 'input'; + + var valueExpression = '$event.target.value'; + if (trim) { + valueExpression = "$event.target.value.trim()"; + } + if (number) { + valueExpression = "_n(" + valueExpression + ")"; + } + + var code = genAssignmentCode(value, valueExpression); + if (needCompositionGuard) { + code = "if($event.target.composing)return;" + code; + } + + addProp(el, 'value', ("(" + value + ")")); + addHandler(el, event, code, null, true); + if (trim || number || type === 'number') { + addHandler(el, 'blur', '$forceUpdate()'); + } +} + +/* */ + +// normalize v-model event tokens that can only be determined at runtime. +// it's important to place the event as the first in the array because +// the whole point is ensuring the v-model callback gets called before +// user-attached handlers. +function normalizeEvents (on) { + var event; + /* istanbul ignore if */ + if (on[RANGE_TOKEN]) { + // IE input[type=range] only supports `change` event + event = isIE ? 'change' : 'input'; + on[event] = [].concat(on[RANGE_TOKEN], on[event] || []); + delete on[RANGE_TOKEN]; + } + if (on[CHECKBOX_RADIO_TOKEN]) { + // Chrome fires microtasks in between click/change, leads to #4521 + event = isChrome ? 'click' : 'change'; + on[event] = [].concat(on[CHECKBOX_RADIO_TOKEN], on[event] || []); + delete on[CHECKBOX_RADIO_TOKEN]; + } +} + +var target$1; + +function add$1 ( + event, + handler, + once, + capture +) { + if (once) { + var oldHandler = handler; + var _target = target$1; // save current target element in closure + handler = function (ev) { + var res = arguments.length === 1 + ? oldHandler(ev) + : oldHandler.apply(null, arguments); + if (res !== null) { + remove$2(event, handler, capture, _target); + } + }; + } + target$1.addEventListener(event, handler, capture); +} + +function remove$2 ( + event, + handler, + capture, + _target +) { + (_target || target$1).removeEventListener(event, handler, capture); +} + +function updateDOMListeners (oldVnode, vnode) { + if (!oldVnode.data.on && !vnode.data.on) { + return + } + var on = vnode.data.on || {}; + var oldOn = oldVnode.data.on || {}; + target$1 = vnode.elm; + normalizeEvents(on); + updateListeners(on, oldOn, add$1, remove$2, vnode.context); +} + +var events = { + create: updateDOMListeners, + update: updateDOMListeners +}; + +/* */ + +function updateDOMProps (oldVnode, vnode) { + if (!oldVnode.data.domProps && !vnode.data.domProps) { + return + } + var key, cur; + var elm = vnode.elm; + var oldProps = oldVnode.data.domProps || {}; + var props = vnode.data.domProps || {}; + // clone observed objects, as the user probably wants to mutate it + if (props.__ob__) { + props = vnode.data.domProps = extend({}, props); + } + + for (key in oldProps) { + if (props[key] == null) { + elm[key] = ''; + } + } + for (key in props) { + cur = props[key]; + // ignore children if the node has textContent or innerHTML, + // as these will throw away existing DOM nodes and cause removal errors + // on subsequent patches (#3360) + if (key === 'textContent' || key === 'innerHTML') { + if (vnode.children) { vnode.children.length = 0; } + if (cur === oldProps[key]) { continue } + } + + if (key === 'value') { + // store value as _value as well since + // non-string values will be stringified + elm._value = cur; + // avoid resetting cursor position when value is the same + var strCur = cur == null ? '' : String(cur); + if (shouldUpdateValue(elm, vnode, strCur)) { + elm.value = strCur; + } + } else { + elm[key] = cur; + } + } +} + +// check platforms/web/util/attrs.js acceptValue + + +function shouldUpdateValue ( + elm, + vnode, + checkVal +) { + return (!elm.composing && ( + vnode.tag === 'option' || + isDirty(elm, checkVal) || + isInputChanged(elm, checkVal) + )) +} + +function isDirty (elm, checkVal) { + // return true when textbox (.number and .trim) loses focus and its value is not equal to the updated value + return document.activeElement !== elm && elm.value !== checkVal +} + +function isInputChanged (elm, newVal) { + var value = elm.value; + var modifiers = elm._vModifiers; // injected by v-model runtime + if ((modifiers && modifiers.number) || elm.type === 'number') { + return toNumber(value) !== toNumber(newVal) + } + if (modifiers && modifiers.trim) { + return value.trim() !== newVal.trim() + } + return value !== newVal +} + +var domProps = { + create: updateDOMProps, + update: updateDOMProps +}; + +/* */ + +var parseStyleText = cached(function (cssText) { + var res = {}; + var listDelimiter = /;(?![^(]*\))/g; + var propertyDelimiter = /:(.+)/; + cssText.split(listDelimiter).forEach(function (item) { + if (item) { + var tmp = item.split(propertyDelimiter); + tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim()); + } + }); + return res +}); + +// merge static and dynamic style data on the same vnode +function normalizeStyleData (data) { + var style = normalizeStyleBinding(data.style); + // static style is pre-processed into an object during compilation + // and is always a fresh object, so it's safe to merge into it + return data.staticStyle + ? extend(data.staticStyle, style) + : style +} + +// normalize possible array / string values into Object +function normalizeStyleBinding (bindingStyle) { + if (Array.isArray(bindingStyle)) { + return toObject(bindingStyle) + } + if (typeof bindingStyle === 'string') { + return parseStyleText(bindingStyle) + } + return bindingStyle +} + +/** + * parent component style should be after child's + * so that parent component's style could override it + */ +function getStyle (vnode, checkChild) { + var res = {}; + var styleData; + + if (checkChild) { + var childNode = vnode; + while (childNode.componentInstance) { + childNode = childNode.componentInstance._vnode; + if (childNode.data && (styleData = normalizeStyleData(childNode.data))) { + extend(res, styleData); + } + } + } + + if ((styleData = normalizeStyleData(vnode.data))) { + extend(res, styleData); + } + + var parentNode = vnode; + while ((parentNode = parentNode.parent)) { + if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) { + extend(res, styleData); + } + } + return res +} + +/* */ + +var cssVarRE = /^--/; +var importantRE = /\s*!important$/; +var setProp = function (el, name, val) { + /* istanbul ignore if */ + if (cssVarRE.test(name)) { + el.style.setProperty(name, val); + } else if (importantRE.test(val)) { + el.style.setProperty(name, val.replace(importantRE, ''), 'important'); + } else { + el.style[normalize(name)] = val; + } +}; + +var prefixes = ['Webkit', 'Moz', 'ms']; + +var testEl; +var normalize = cached(function (prop) { + testEl = testEl || document.createElement('div'); + prop = camelize(prop); + if (prop !== 'filter' && (prop in testEl.style)) { + return prop + } + var upper = prop.charAt(0).toUpperCase() + prop.slice(1); + for (var i = 0; i < prefixes.length; i++) { + var prefixed = prefixes[i] + upper; + if (prefixed in testEl.style) { + return prefixed + } + } +}); + +function updateStyle (oldVnode, vnode) { + var data = vnode.data; + var oldData = oldVnode.data; + + if (!data.staticStyle && !data.style && + !oldData.staticStyle && !oldData.style) { + return + } + + var cur, name; + var el = vnode.elm; + var oldStaticStyle = oldVnode.data.staticStyle; + var oldStyleBinding = oldVnode.data.style || {}; + + // if static style exists, stylebinding already merged into it when doing normalizeStyleData + var oldStyle = oldStaticStyle || oldStyleBinding; + + var style = normalizeStyleBinding(vnode.data.style) || {}; + + vnode.data.style = style.__ob__ ? extend({}, style) : style; + + var newStyle = getStyle(vnode, true); + + for (name in oldStyle) { + if (newStyle[name] == null) { + setProp(el, name, ''); + } + } + for (name in newStyle) { + cur = newStyle[name]; + if (cur !== oldStyle[name]) { + // ie9 setting to null has no effect, must use empty string + setProp(el, name, cur == null ? '' : cur); + } + } +} + +var style = { + create: updateStyle, + update: updateStyle +}; + +/* */ + +/** + * Add class with compatibility for SVG since classList is not supported on + * SVG elements in IE + */ +function addClass (el, cls) { + /* istanbul ignore if */ + if (!cls || !(cls = cls.trim())) { + return + } + + /* istanbul ignore else */ + if (el.classList) { + if (cls.indexOf(' ') > -1) { + cls.split(/\s+/).forEach(function (c) { return el.classList.add(c); }); + } else { + el.classList.add(cls); + } + } else { + var cur = " " + (el.getAttribute('class') || '') + " "; + if (cur.indexOf(' ' + cls + ' ') < 0) { + el.setAttribute('class', (cur + cls).trim()); + } + } +} + +/** + * Remove class with compatibility for SVG since classList is not supported on + * SVG elements in IE + */ +function removeClass (el, cls) { + /* istanbul ignore if */ + if (!cls || !(cls = cls.trim())) { + return + } + + /* istanbul ignore else */ + if (el.classList) { + if (cls.indexOf(' ') > -1) { + cls.split(/\s+/).forEach(function (c) { return el.classList.remove(c); }); + } else { + el.classList.remove(cls); + } + } else { + var cur = " " + (el.getAttribute('class') || '') + " "; + var tar = ' ' + cls + ' '; + while (cur.indexOf(tar) >= 0) { + cur = cur.replace(tar, ' '); + } + el.setAttribute('class', cur.trim()); + } +} + +/* */ + +function resolveTransition (def$$1) { + if (!def$$1) { + return + } + /* istanbul ignore else */ + if (typeof def$$1 === 'object') { + var res = {}; + if (def$$1.css !== false) { + extend(res, autoCssTransition(def$$1.name || 'v')); + } + extend(res, def$$1); + return res + } else if (typeof def$$1 === 'string') { + return autoCssTransition(def$$1) + } +} + +var autoCssTransition = cached(function (name) { + return { + enterClass: (name + "-enter"), + enterToClass: (name + "-enter-to"), + enterActiveClass: (name + "-enter-active"), + leaveClass: (name + "-leave"), + leaveToClass: (name + "-leave-to"), + leaveActiveClass: (name + "-leave-active") + } +}); + +var hasTransition = inBrowser && !isIE9; +var TRANSITION = 'transition'; +var ANIMATION = 'animation'; + +// Transition property/event sniffing +var transitionProp = 'transition'; +var transitionEndEvent = 'transitionend'; +var animationProp = 'animation'; +var animationEndEvent = 'animationend'; +if (hasTransition) { + /* istanbul ignore if */ + if (window.ontransitionend === undefined && + window.onwebkittransitionend !== undefined) { + transitionProp = 'WebkitTransition'; + transitionEndEvent = 'webkitTransitionEnd'; + } + if (window.onanimationend === undefined && + window.onwebkitanimationend !== undefined) { + animationProp = 'WebkitAnimation'; + animationEndEvent = 'webkitAnimationEnd'; + } +} + +// binding to window is necessary to make hot reload work in IE in strict mode +var raf = inBrowser && window.requestAnimationFrame + ? window.requestAnimationFrame.bind(window) + : setTimeout; + +function nextFrame (fn) { + raf(function () { + raf(fn); + }); +} + +function addTransitionClass (el, cls) { + (el._transitionClasses || (el._transitionClasses = [])).push(cls); + addClass(el, cls); +} + +function removeTransitionClass (el, cls) { + if (el._transitionClasses) { + remove(el._transitionClasses, cls); + } + removeClass(el, cls); +} + +function whenTransitionEnds ( + el, + expectedType, + cb +) { + var ref = getTransitionInfo(el, expectedType); + var type = ref.type; + var timeout = ref.timeout; + var propCount = ref.propCount; + if (!type) { return cb() } + var event = type === TRANSITION ? transitionEndEvent : animationEndEvent; + var ended = 0; + var end = function () { + el.removeEventListener(event, onEnd); + cb(); + }; + var onEnd = function (e) { + if (e.target === el) { + if (++ended >= propCount) { + end(); + } + } + }; + setTimeout(function () { + if (ended < propCount) { + end(); + } + }, timeout + 1); + el.addEventListener(event, onEnd); +} + +var transformRE = /\b(transform|all)(,|$)/; + +function getTransitionInfo (el, expectedType) { + var styles = window.getComputedStyle(el); + var transitionDelays = styles[transitionProp + 'Delay'].split(', '); + var transitionDurations = styles[transitionProp + 'Duration'].split(', '); + var transitionTimeout = getTimeout(transitionDelays, transitionDurations); + var animationDelays = styles[animationProp + 'Delay'].split(', '); + var animationDurations = styles[animationProp + 'Duration'].split(', '); + var animationTimeout = getTimeout(animationDelays, animationDurations); + + var type; + var timeout = 0; + var propCount = 0; + /* istanbul ignore if */ + if (expectedType === TRANSITION) { + if (transitionTimeout > 0) { + type = TRANSITION; + timeout = transitionTimeout; + propCount = transitionDurations.length; + } + } else if (expectedType === ANIMATION) { + if (animationTimeout > 0) { + type = ANIMATION; + timeout = animationTimeout; + propCount = animationDurations.length; + } + } else { + timeout = Math.max(transitionTimeout, animationTimeout); + type = timeout > 0 + ? transitionTimeout > animationTimeout + ? TRANSITION + : ANIMATION + : null; + propCount = type + ? type === TRANSITION + ? transitionDurations.length + : animationDurations.length + : 0; + } + var hasTransform = + type === TRANSITION && + transformRE.test(styles[transitionProp + 'Property']); + return { + type: type, + timeout: timeout, + propCount: propCount, + hasTransform: hasTransform + } +} + +function getTimeout (delays, durations) { + /* istanbul ignore next */ + while (delays.length < durations.length) { + delays = delays.concat(delays); + } + + return Math.max.apply(null, durations.map(function (d, i) { + return toMs(d) + toMs(delays[i]) + })) +} + +function toMs (s) { + return Number(s.slice(0, -1)) * 1000 +} + +/* */ + +function enter (vnode, toggleDisplay) { + var el = vnode.elm; + + // call leave callback now + if (el._leaveCb) { + el._leaveCb.cancelled = true; + el._leaveCb(); + } + + var data = resolveTransition(vnode.data.transition); + if (!data) { + return + } + + /* istanbul ignore if */ + if (el._enterCb || el.nodeType !== 1) { + return + } + + var css = data.css; + var type = data.type; + var enterClass = data.enterClass; + var enterToClass = data.enterToClass; + var enterActiveClass = data.enterActiveClass; + var appearClass = data.appearClass; + var appearToClass = data.appearToClass; + var appearActiveClass = data.appearActiveClass; + var beforeEnter = data.beforeEnter; + var enter = data.enter; + var afterEnter = data.afterEnter; + var enterCancelled = data.enterCancelled; + var beforeAppear = data.beforeAppear; + var appear = data.appear; + var afterAppear = data.afterAppear; + var appearCancelled = data.appearCancelled; + var duration = data.duration; + + // activeInstance will always be the