docs: function enter (vnode) {
  	  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 enterActiveClass = data.enterActiveClass;
  	  var appearClass = data.appearClass;
  	  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;
  	
  	  // activeInstance will always be the <transition> component managing this
  	  // transition. One edge case to check is when the <transition> is placed
  	  // as the root node of a child component. In that case we need to check
  	  // <transition>'s parent for appear check.
  	  var transitionNode = activeInstance.$vnode;
  	  var context = transitionNode && transitionNode.parent
  	    ? transitionNode.parent.context
  	    : activeInstance;
  	
  	  var isAppear = !context._isMounted || !vnode.isRootInsert;
  	
  	  if (isAppear && !appear && appear !== '') {
  	    return
  	  }
  	
  	  var startClass = isAppear ? appearClass : enterClass;
  	  var activeClass = isAppear ? appearActiveClass : enterActiveClass;
  	  var beforeEnterHook = isAppear ? (beforeAppear || beforeEnter) : beforeEnter;
  	  var enterHook = isAppear ? (typeof appear === 'function' ? appear : enter) : enter;
  	  var afterEnterHook = isAppear ? (afterAppear || afterEnter) : afterEnter;
  	  var enterCancelledHook = isAppear ? (appearCancelled || enterCancelled) : enterCancelled;
  	
  	  var expectsCSS = css !== false && !isIE9;
  	  var userWantsControl =
  	    enterHook &&
  	    // enterHook may be a bound method which exposes
  	    // the length of original fn as _length
  	    (enterHook._length || enterHook.length) > 1;
  	
  	  var cb = el._enterCb = once(function () {
  	    if (expectsCSS) {
  	      removeTransitionClass(el, activeClass);
  	    }
  	    if (cb.cancelled) {
  	      if (expectsCSS) {
  	        removeTransitionClass(el, startClass);
  	      }
  	      enterCancelledHook && enterCancelledHook(el);
  	    } else {
  	      afterEnterHook && afterEnterHook(el);
  	    }
  	    el._enterCb = null;
  	  });
  	
  	  if (!vnode.data.show) {
  	    // remove pending leave element on enter by injecting an insert hook
  	    mergeVNodeHook(vnode.data.hook || (vnode.data.hook = {}), 'insert', function () {
  	      var parent = el.parentNode;
  	      var pendingNode = parent && parent._pending && parent._pending[vnode.key];
  	      if (pendingNode && pendingNode.tag === vnode.tag && pendingNode.elm._leaveCb) {
  	        pendingNode.elm._leaveCb();
  	      }
  	      enterHook && enterHook(el, cb);
  	    }, 'transition-insert');
  	  }
  	
  	  // start enter transition
  	  beforeEnterHook && beforeEnterHook(el);
  	  if (expectsCSS) {
  	    addTransitionClass(el, startClass);
  	    addTransitionClass(el, activeClass);
  	    nextFrame(function () {
  	      removeTransitionClass(el, startClass);
  	      if (!cb.cancelled && !userWantsControl) {
  	        whenTransitionEnds(el, type, cb);
  	      }
  	    });
  	  }
  	
  	  if (vnode.data.show) {
  	    enterHook && enterHook(el, cb);
  	  }
  	
  	  if (!expectsCSS && !userWantsControl) {
  	    cb();
  	  }
  	}