diff --git a/1.Vue/flow/compiler.js b/1.Vue/flow/compiler.js
deleted file mode 100644
index ad09a2e..0000000
--- a/1.Vue/flow/compiler.js
+++ /dev/null
@@ -1,227 +0,0 @@
-declare type CompilerOptions = {
-  warn?: Function; // allow customizing warning in different environments; e.g. node
-  modules?: Array<ModuleOptions>; // platform specific modules; e.g. style; class
-  directives?: { [key: string]: Function }; // platform specific directives
-  staticKeys?: string; // a list of AST properties to be considered static; for optimization
-  isUnaryTag?: (tag: string) => ?boolean; // check if a tag is unary for the platform
-  canBeLeftOpenTag?: (tag: string) => ?boolean; // check if a tag can be left opened
-  isReservedTag?: (tag: string) => ?boolean; // check if a tag is a native for the platform
-  preserveWhitespace?: boolean; // preserve whitespace between elements? (Deprecated)
-  whitespace?: 'preserve' | 'condense'; // whitespace handling strategy
-  optimize?: boolean; // optimize static content?
-
-  // web specific
-  mustUseProp?: (tag: string, type: ?string, name: string) => boolean; // check if an attribute should be bound as a property
-  isPreTag?: (attr: string) => ?boolean; // check if a tag needs to preserve whitespace
-  getTagNamespace?: (tag: string) => ?string; // check the namespace for a tag
-  expectHTML?: boolean; // only false for non-web builds
-  isFromDOM?: boolean;
-  shouldDecodeTags?: boolean;
-  shouldDecodeNewlines?:  boolean;
-  shouldDecodeNewlinesForHref?: boolean;
-  outputSourceRange?: boolean;
-
-  // runtime user-configurable
-  delimiters?: [string, string]; // template delimiters
-  comments?: boolean; // preserve comments in template
-
-  // for ssr optimization compiler
-  scopeId?: string;
-};
-
-declare type WarningMessage = {
-  msg: string;
-  start?: number;
-  end?: number;
-};
-
-declare type CompiledResult = {
-  ast: ?ASTElement;
-  render: string;
-  staticRenderFns: Array<string>;
-  stringRenderFns?: Array<string>;
-  errors?: Array<string | WarningMessage>;
-  tips?: Array<string | WarningMessage>;
-};
-
-declare type ModuleOptions = {
-  // transform an AST node before any attributes are processed
-  // returning an ASTElement from pre/transforms replaces the element
-  preTransformNode: (el: ASTElement) => ?ASTElement;
-  // transform an AST node after built-ins like v-if, v-for are processed
-  transformNode: (el: ASTElement) => ?ASTElement;
-  // transform an AST node after its children have been processed
-  // cannot return replacement in postTransform because tree is already finalized
-  postTransformNode: (el: ASTElement) => void;
-  genData: (el: ASTElement) => string; // generate extra data string for an element
-  transformCode?: (el: ASTElement, code: string) => string; // further transform generated code for an element
-  staticKeys?: Array<string>; // AST properties to be considered static
-};
-
-declare type ASTModifiers = { [key: string]: boolean };
-declare type ASTIfCondition = { exp: ?string; block: ASTElement };
-declare type ASTIfConditions = Array<ASTIfCondition>;
-
-declare type ASTAttr = {
-  name: string;
-  value: any;
-  dynamic?: boolean;
-  start?: number;
-  end?: number
-};
-
-declare type ASTElementHandler = {
-  value: string;
-  params?: Array<any>;
-  modifiers: ?ASTModifiers;
-  dynamic?: boolean;
-  start?: number;
-  end?: number;
-};
-
-declare type ASTElementHandlers = {
-  [key: string]: ASTElementHandler | Array<ASTElementHandler>;
-};
-
-declare type ASTDirective = {
-  name: string;
-  rawName: string;
-  value: string;
-  arg: ?string;
-  isDynamicArg: boolean;
-  modifiers: ?ASTModifiers;
-  start?: number;
-  end?: number;
-};
-
-declare type ASTNode = ASTElement | ASTText | ASTExpression;
-
-declare type ASTElement = {
-  type: 1;
-  tag: string;
-  attrsList: Array<ASTAttr>;
-  attrsMap: { [key: string]: any };
-  rawAttrsMap: { [key: string]: ASTAttr };
-  parent: ASTElement | void;
-  children: Array<ASTNode>;
-
-  start?: number;
-  end?: number;
-
-  processed?: true;
-
-  static?: boolean;
-  staticRoot?: boolean;
-  staticInFor?: boolean;
-  staticProcessed?: boolean;
-  hasBindings?: boolean;
-
-  text?: string;
-  attrs?: Array<ASTAttr>;
-  dynamicAttrs?: Array<ASTAttr>;
-  props?: Array<ASTAttr>;
-  plain?: boolean;
-  pre?: true;
-  ns?: string;
-
-  component?: string;
-  inlineTemplate?: true;
-  transitionMode?: string | null;
-  slotName?: ?string;
-  slotTarget?: ?string;
-  slotTargetDynamic?: boolean;
-  slotScope?: ?string;
-  scopedSlots?: { [name: string]: ASTElement };
-
-  ref?: string;
-  refInFor?: boolean;
-
-  if?: string;
-  ifProcessed?: boolean;
-  elseif?: string;
-  else?: true;
-  ifConditions?: ASTIfConditions;
-
-  for?: string;
-  forProcessed?: boolean;
-  key?: string;
-  alias?: string;
-  iterator1?: string;
-  iterator2?: string;
-
-  staticClass?: string;
-  classBinding?: string;
-  staticStyle?: string;
-  styleBinding?: string;
-  events?: ASTElementHandlers;
-  nativeEvents?: ASTElementHandlers;
-
-  transition?: string | true;
-  transitionOnAppear?: boolean;
-
-  model?: {
-    value: string;
-    callback: string;
-    expression: string;
-  };
-
-  directives?: Array<ASTDirective>;
-
-  forbidden?: true;
-  once?: true;
-  onceProcessed?: boolean;
-  wrapData?: (code: string) => string;
-  wrapListeners?: (code: string) => string;
-
-  // 2.4 ssr optimization
-  ssrOptimizability?: number;
-
-  // weex specific
-  appendAsTree?: boolean;
-};
-
-declare type ASTExpression = {
-  type: 2;
-  expression: string;
-  text: string;
-  tokens: Array<string | Object>;
-  static?: boolean;
-  // 2.4 ssr optimization
-  ssrOptimizability?: number;
-  start?: number;
-  end?: number;
-};
-
-declare type ASTText = {
-  type: 3;
-  text: string;
-  static?: boolean;
-  isComment?: boolean;
-  // 2.4 ssr optimization
-  ssrOptimizability?: number;
-  start?: number;
-  end?: number;
-};
-
-// SFC-parser related declarations
-
-// an object format describing a single-file component
-declare type SFCDescriptor = {
-  template: ?SFCBlock;
-  script: ?SFCBlock;
-  styles: Array<SFCBlock>;
-  customBlocks: Array<SFCBlock>;
-  errors: Array<string | WarningMessage>;
-}
-
-declare type SFCBlock = {
-  type: string;
-  content: string;
-  attrs: {[attribute:string]: string};
-  start?: number;
-  end?: number;
-  lang?: string;
-  src?: string;
-  scoped?: boolean;
-  module?: string | boolean;
-};
diff --git a/1.Vue/flow/component.js b/1.Vue/flow/component.js
deleted file mode 100644
index 0dc67a4..0000000
--- a/1.Vue/flow/component.js
+++ /dev/null
@@ -1,148 +0,0 @@
-import type { Config } from '../src/core/config'
-import type VNode from '../src/core/vdom/vnode'
-import type Watcher from '../src/core/observer/watcher'
-
-declare interface Component {
-  // constructor information
-  static cid: number;
-  static options: Object;
-  // extend
-  static extend: (options: Object) => Function;
-  static superOptions: Object;
-  static extendOptions: Object;
-  static sealedOptions: Object;
-  static super: Class<Component>;
-  // assets
-  static directive: (id: string, def?: Function | Object) => Function | Object | void;
-  static component: (id: string, def?: Class<Component> | Object) => Class<Component>;
-  static filter: (id: string, def?: Function) => Function | void;
-  // functional context constructor
-  static FunctionalRenderContext: Function;
-
-  // public properties
-  $el: any; // so that we can attach __vue__ to it
-  $data: Object;
-  $props: Object;
-  $options: ComponentOptions;
-  $parent: Component | void;
-  $root: Component;
-  $children: Array<Component>;
-  $refs: { [key: string]: Component | Element | Array<Component | Element> | void };
-  $slots: { [key: string]: Array<VNode> };
-  $scopedSlots: { [key: string]: () => VNodeChildren };
-  $vnode: VNode; // the placeholder node for the component in parent's render tree
-  $attrs: { [key: string] : string };
-  $listeners: { [key: string]: Function | Array<Function> };
-  $isServer: boolean;
-
-  // public methods
-  $mount: (el?: Element | string, hydrating?: boolean) => Component;
-  $forceUpdate: () => void;
-  $destroy: () => void;
-  $set: <T>(target: Object | Array<T>, key: string | number, val: T) => T;
-  $delete: <T>(target: Object | Array<T>, key: string | number) => void;
-  $watch: (expOrFn: string | Function, cb: Function, options?: Object) => Function;
-  $on: (event: string | Array<string>, fn: Function) => Component;
-  $once: (event: string, fn: Function) => Component;
-  $off: (event?: string | Array<string>, fn?: Function) => Component;
-  $emit: (event: string, ...args: Array<mixed>) => Component;
-  $nextTick: (fn: Function) => void | Promise<*>;
-  $createElement: (tag?: string | Component, data?: Object, children?: VNodeChildren) => VNode;
-
-  // private properties
-  _uid: number | string;
-  _name: string; // this only exists in dev mode
-  _isVue: true;
-  _self: Component;
-  _renderProxy: Component;
-  _renderContext: ?Component;
-  _watcher: Watcher;
-  _watchers: Array<Watcher>;
-  _computedWatchers: { [key: string]: Watcher };
-  _data: Object;
-  _props: Object;
-  _events: Object;
-  _inactive: boolean | null;
-  _directInactive: boolean;
-  _isMounted: boolean;
-  _isDestroyed: boolean;
-  _isBeingDestroyed: boolean;
-  _vnode: ?VNode; // self root node
-  _staticTrees: ?Array<VNode>; // v-once cached trees
-  _hasHookEvent: boolean;
-  _provided: ?Object;
-  // _virtualComponents?: { [key: string]: Component };
-
-  // private methods
-
-  // lifecycle
-  _init: Function;
-  _mount: (el?: Element | void, hydrating?: boolean) => Component;
-  _update: (vnode: VNode, hydrating?: boolean) => void;
-
-  // rendering
-  _render: () => VNode;
-
-  __patch__: (
-    a: Element | VNode | void,
-    b: VNode,
-    hydrating?: boolean,
-    removeOnly?: boolean,
-    parentElm?: any,
-    refElm?: any
-  ) => any;
-
-  // createElement
-
-  // _c is internal that accepts `normalizationType` optimization hint
-  _c: (
-    vnode?: VNode,
-    data?: VNodeData,
-    children?: VNodeChildren,
-    normalizationType?: number
-  ) => VNode | void;
-
-  // renderStatic
-  _m: (index: number, isInFor?: boolean) => VNode | VNodeChildren;
-  // markOnce
-  _o: (vnode: VNode | Array<VNode>, index: number, key: string) => VNode | VNodeChildren;
-  // toString
-  _s: (value: mixed) => string;
-  // text to VNode
-  _v: (value: string | number) => VNode;
-  // toNumber
-  _n: (value: string) => number | string;
-  // empty vnode
-  _e: () => VNode;
-  // loose equal
-  _q: (a: mixed, b: mixed) => boolean;
-  // loose indexOf
-  _i: (arr: Array<mixed>, val: mixed) => number;
-  // resolveFilter
-  _f: (id: string) => Function;
-  // renderList
-  _l: (val: mixed, render: Function) => ?Array<VNode>;
-  // renderSlot
-  _t: (name: string, fallback: ?Array<VNode>, props: ?Object) => ?Array<VNode>;
-  // apply v-bind object
-  _b: (data: any, tag: string, value: any, asProp: boolean, isSync?: boolean) => VNodeData;
-  // apply v-on object
-  _g: (data: any, value: any) => VNodeData;
-  // check custom keyCode
-  _k: (eventKeyCode: number, key: string, builtInAlias?: number | Array<number>, eventKeyName?: string) => ?boolean;
-  // resolve scoped slots
-  _u: (scopedSlots: ScopedSlotsData, res?: Object) => { [key: string]: Function };
-
-  // SSR specific
-  _ssrNode: Function;
-  _ssrList: Function;
-  _ssrEscape: Function;
-  _ssrAttr: Function;
-  _ssrAttrs: Function;
-  _ssrDOMProps: Function;
-  _ssrClass: Function;
-  _ssrStyle: Function;
-
-  // allow dynamic method registration
-  [key: string]: any
-};
diff --git a/1.Vue/flow/global-api.js b/1.Vue/flow/global-api.js
deleted file mode 100644
index 0ce54fd..0000000
--- a/1.Vue/flow/global-api.js
+++ /dev/null
@@ -1,23 +0,0 @@
-declare interface GlobalAPI {
-  cid: number;
-  options: Object;
-  config: Config;
-  util: Object;
-
-  extend: (options: Object) => Function;
-  set: <T>(target: Object | Array<T>, key: string | number, value: T) => T;
-  delete: <T>(target: Object| Array<T>, key: string | number) => void;
-  nextTick: (fn: Function, context?: Object) => void | Promise<*>;
-  use: (plugin: Function | Object) => GlobalAPI;
-  mixin: (mixin: Object) => GlobalAPI;
-  compile: (template: string) => { render: Function, staticRenderFns: Array<Function> };
-
-  directive: (id: string, def?: Function | Object) => Function | Object | void;
-  component: (id: string, def?: Class<Component> | Object) => Class<Component>;
-  filter: (id: string, def?: Function) => Function | void;
-
-  observable: <T>(value: T) => T;
-
-  // allow dynamic method registration
-  [key: string]: any
-};
diff --git a/1.Vue/flow/modules.js b/1.Vue/flow/modules.js
deleted file mode 100644
index a660e9c..0000000
--- a/1.Vue/flow/modules.js
+++ /dev/null
@@ -1,44 +0,0 @@
-declare module 'he' {
-  declare function escape(html: string): string;
-  declare function decode(html: string): string;
-}
-
-declare module 'source-map' {
-  declare class SourceMapGenerator {
-    setSourceContent(filename: string, content: string): void;
-    addMapping(mapping: Object): void;
-    toString(): string;
-  }
-  declare class SourceMapConsumer {
-    constructor (map: Object): void;
-    originalPositionFor(position: { line: number; column: number; }): {
-      source: ?string;
-      line: ?number;
-      column: ?number;
-    };
-  }
-}
-
-declare module 'lru-cache' {
-  declare var exports: {
-    (): any
-  }
-}
-
-declare module 'de-indent' {
-  declare var exports: {
-    (input: string): string
-  }
-}
-
-declare module 'serialize-javascript' {
-  declare var exports: {
-    (input: string, options: { isJSON: boolean }): string
-  }
-}
-
-declare module 'lodash.template' {
-  declare var exports: {
-    (input: string, options: { interpolate: RegExp, escape: RegExp }): Function
-  }
-}
diff --git a/1.Vue/flow/options.js b/1.Vue/flow/options.js
deleted file mode 100644
index 09bd93f..0000000
--- a/1.Vue/flow/options.js
+++ /dev/null
@@ -1,90 +0,0 @@
-declare type InternalComponentOptions = {
-  _isComponent: true;
-  parent: Component;
-  _parentVnode: VNode;
-  render?: Function;
-  staticRenderFns?: Array<Function>
-};
-
-type InjectKey = string | Symbol;
-
-declare type ComponentOptions = {
-  componentId?: string;
-
-  // data
-  data: Object | Function | void;
-  props?: { [key: string]: PropOptions };
-  propsData?: ?Object;
-  computed?: {
-    [key: string]: Function | {
-      get?: Function;
-      set?: Function;
-      cache?: boolean
-    }
-  };
-  methods?: { [key: string]: Function };
-  watch?: { [key: string]: Function | string };
-
-  // DOM
-  el?: string | Element;
-  template?: string;
-  render: (h: () => VNode) => VNode;
-  renderError?: (h: () => VNode, err: Error) => VNode;
-  staticRenderFns?: Array<() => VNode>;
-
-  // lifecycle
-  beforeCreate?: Function;
-  created?: Function;
-  beforeMount?: Function;
-  mounted?: Function;
-  beforeUpdate?: Function;
-  updated?: Function;
-  activated?: Function;
-  deactivated?: Function;
-  beforeDestroy?: Function;
-  destroyed?: Function;
-  errorCaptured?: () => boolean | void;
-  serverPrefetch?: Function;
-
-  // assets
-  directives?: { [key: string]: Object };
-  components?: { [key: string]: Class<Component> };
-  transitions?: { [key: string]: Object };
-  filters?: { [key: string]: Function };
-
-  // context
-  provide?: { [key: string | Symbol]: any } | () => { [key: string | Symbol]: any };
-  inject?: { [key: string]: InjectKey | { from?: InjectKey, default?: any }} | Array<string>;
-
-  // component v-model customization
-  model?: {
-    prop?: string;
-    event?: string;
-  };
-
-  // misc
-  parent?: Component;
-  mixins?: Array<Object>;
-  name?: string;
-  extends?: Class<Component> | Object;
-  delimiters?: [string, string];
-  comments?: boolean;
-  inheritAttrs?: boolean;
-
-  // private
-  _isComponent?: true;
-  _propKeys?: Array<string>;
-  _parentVnode?: VNode;
-  _parentListeners?: ?Object;
-  _renderChildren?: ?Array<VNode>;
-  _componentTag: ?string;
-  _scopeId: ?string;
-  _base: Class<Component>;
-};
-
-declare type PropOptions = {
-  type: Function | Array<Function> | null;
-  default: any;
-  required: ?boolean;
-  validator: ?Function;
-}
diff --git a/1.Vue/flow/ssr.js b/1.Vue/flow/ssr.js
deleted file mode 100644
index d6a9459..0000000
--- a/1.Vue/flow/ssr.js
+++ /dev/null
@@ -1,21 +0,0 @@
-declare type ComponentWithCacheContext = {
-  type: 'ComponentWithCache';
-  bufferIndex: number;
-  buffer: Array<string>;
-  key: string;
-};
-
-declare type ElementContext = {
-  type: 'Element';
-  children: Array<VNode>;
-  rendered: number;
-  endTag: string;
-  total: number;
-};
-
-declare type ComponentContext = {
-  type: 'Component';
-  prevActive: Component;
-};
-
-declare type RenderState = ComponentContext | ComponentWithCacheContext | ElementContext;
diff --git a/1.Vue/flow/vnode.js b/1.Vue/flow/vnode.js
deleted file mode 100644
index c9f3b38..0000000
--- a/1.Vue/flow/vnode.js
+++ /dev/null
@@ -1,79 +0,0 @@
-declare type VNodeChildren = Array<?VNode | string | VNodeChildren> | string;
-
-declare type VNodeComponentOptions = {
-  Ctor: Class<Component>;
-  propsData: ?Object;
-  listeners: ?Object;
-  children: ?Array<VNode>;
-  tag?: string;
-};
-
-declare type MountedComponentVNode = {
-  context: Component;
-  componentOptions: VNodeComponentOptions;
-  componentInstance: Component;
-  parent: VNode;
-  data: VNodeData;
-};
-
-// interface for vnodes in update modules
-declare type VNodeWithData = {
-  tag: string;
-  data: VNodeData;
-  children: ?Array<VNode>;
-  text: void;
-  elm: any;
-  ns: string | void;
-  context: Component;
-  key: string | number | void;
-  parent?: VNodeWithData;
-  componentOptions?: VNodeComponentOptions;
-  componentInstance?: Component;
-  isRootInsert: boolean;
-};
-
-declare interface VNodeData {
-  key?: string | number;
-  slot?: string;
-  ref?: string;
-  is?: string;
-  pre?: boolean;
-  tag?: string;
-  staticClass?: string;
-  class?: any;
-  staticStyle?: { [key: string]: any };
-  style?: string | Array<Object> | Object;
-  normalizedStyle?: Object;
-  props?: { [key: string]: any };
-  attrs?: { [key: string]: string };
-  domProps?: { [key: string]: any };
-  hook?: { [key: string]: Function };
-  on?: ?{ [key: string]: Function | Array<Function> };
-  nativeOn?: { [key: string]: Function | Array<Function> };
-  transition?: Object;
-  show?: boolean; // marker for v-show
-  inlineTemplate?: {
-    render: Function;
-    staticRenderFns: Array<Function>;
-  };
-  directives?: Array<VNodeDirective>;
-  keepAlive?: boolean;
-  scopedSlots?: { [key: string]: Function };
-  model?: {
-    value: any;
-    callback: Function;
-  };
-};
-
-declare type VNodeDirective = {
-  name: string;
-  rawName: string;
-  value?: any;
-  oldValue?: any;
-  arg?: string;
-  oldArg?: string;
-  modifiers?: ASTModifiers;
-  def?: Object;
-};
-
-declare type ScopedSlotsData = Array<{ key: string, fn: Function } | ScopedSlotsData>;
diff --git a/1.Vue/flow/weex.js b/1.Vue/flow/weex.js
deleted file mode 100644
index 2834313..0000000
--- a/1.Vue/flow/weex.js
+++ /dev/null
@@ -1,122 +0,0 @@
-// global flag to be compiled away
-declare var __WEEX__: boolean;
-
-// global object in Weex
-declare var WXEnvironment: WeexEnvironment;
-
-declare type Weex = {
-  config: WeexConfigAPI;
-  document: WeexDocument;
-  requireModule: (name: string) => Object | void;
-  supports: (condition: string) => boolean | void;
-  isRegisteredModule: (name: string, method?: string) => boolean;
-  isRegisteredComponent: (name: string) => boolean;
-};
-
-declare type WeexConfigAPI = {
-  bundleUrl: string; // === weex.document.URL
-  bundleType: string;
-  env: WeexEnvironment; // === WXEnvironment
-};
-
-declare type WeexEnvironment = {
-  platform: string; // could be "Web", "iOS", "Android"
-  weexVersion: string; // the version of WeexSDK
-
-  osName: string; // could be "iOS", "Android" or others
-  osVersion: string;
-  appName: string; // mobile app name or browser name
-  appVersion: string;
-
-  // informations of current running device
-  deviceModel: string; // phone device model
-  deviceWidth: number;
-  deviceHeight: number;
-  scale: number;
-
-  // only available on the web
-  userAgent?: string;
-  dpr?: number;
-  rem?: number;
-};
-
-declare interface WeexDocument {
-  id: string;
-  URL: string;
-  taskCenter: WeexTaskCenter;
-
-  open: () => void;
-  close: () => void;
-  createElement: (tagName: string, props?: Object) => WeexElement;
-  createComment: (text: string) => Object;
-  fireEvent: (type: string) => void;
-  destroy: () => void;
-};
-
-declare interface WeexTaskCenter {
-  instanceId: string;
-  callbackManager: Object;
-  send: (type: string, params: Object, args: Array<any>, options?: Object) => void;
-  registerHook: (componentId: string, type: string, hook: string, fn: Function) => void;
-  updateData: (componentId: string, data: Object | void, callback?: Function) => void;
-};
-
-declare interface WeexElement {
-  nodeType: number;
-  nodeId: string;
-  type: string;
-  ref: string;
-  text?: string;
-
-  parentNode: WeexElement | void;
-  children: Array<WeexElement>;
-  previousSibling: WeexElement | void;
-  nextSibling: WeexElement | void;
-
-  appendChild: (node: WeexElement) => void;
-  removeChild: (node: WeexElement, preserved?: boolean) => void;
-  insertBefore: (node: WeexElement, before: WeexElement) => void;
-  insertAfter: (node: WeexElement, after: WeexElement) => void;
-  setAttr: (key: string, value: any, silent?: boolean) => void;
-  setAttrs: (attrs: Object, silent?: boolean) => void;
-  setStyle: (key: string, value: any, silent?: boolean) => void;
-  setStyles: (attrs: Object, silent?: boolean) => void;
-  addEvent: (type: string, handler: Function, args?: Array<any>) => void;
-  removeEvent: (type: string) => void;
-  fireEvent: (type: string) => void;
-  destroy: () => void;
-};
-
-declare type WeexInstanceOption = {
-  instanceId: string;
-  config: WeexConfigAPI;
-  document: WeexDocument;
-  Vue?: GlobalAPI;
-  app?: Component;
-  data?: Object;
-};
-
-declare type WeexRuntimeContext = {
-  weex: Weex;
-  service: Object;
-  BroadcastChannel?: Function;
-};
-
-declare type WeexInstanceContext = {
-  Vue: GlobalAPI;
-
-  // DEPRECATED
-  setTimeout?: Function;
-  clearTimeout?: Function;
-  setInterval?: Function;
-  clearInterval?: Function;
-};
-
-declare type WeexCompilerOptions = CompilerOptions & {
-  // whether to compile special template for <recycle-list>
-  recyclable?: boolean;
-};
-
-declare type WeexCompiledResult = CompiledResult & {
-  '@render'?: string;
-};
diff --git a/1.Vue/src/compiler/codeframe.js b/1.Vue/src/compiler/codeframe.js
deleted file mode 100644
index 513d318..0000000
--- a/1.Vue/src/compiler/codeframe.js
+++ /dev/null
@@ -1,50 +0,0 @@
-/* @flow */
-
-const range = 2
-
-export function generateCodeFrame (
-  source: string,
-  start: number = 0,
-  end: number = source.length
-): string {
-  const lines = source.split(/\r?\n/)
-  let count = 0
-  const res = []
-  for (let i = 0; i < lines.length; i++) {
-    count += lines[i].length + 1
-    if (count >= start) {
-      for (let j = i - range; j <= i + range || end > count; j++) {
-        if (j < 0 || j >= lines.length) continue
-        res.push(`${j + 1}${repeat(` `, 3 - String(j + 1).length)}|  ${lines[j]}`)
-        const lineLength = lines[j].length
-        if (j === i) {
-          // push underline
-          const pad = start - (count - lineLength) + 1
-          const length = end > count ? lineLength - pad : end - start
-          res.push(`   |  ` + repeat(` `, pad) + repeat(`^`, length))
-        } else if (j > i) {
-          if (end > count) {
-            const length = Math.min(end - count, lineLength)
-            res.push(`   |  ` + repeat(`^`, length))
-          }
-          count += lineLength + 1
-        }
-      }
-      break
-    }
-  }
-  return res.join('\n')
-}
-
-function repeat (str, n) {
-  let result = ''
-  if (n > 0) {
-    while (true) { // eslint-disable-line
-      if (n & 1) result += str
-      n >>>= 1
-      if (n <= 0) break
-      str += str
-    }
-  }
-  return result
-}
diff --git a/1.Vue/src/compiler/codegen/events.js b/1.Vue/src/compiler/codegen/events.js
deleted file mode 100644
index 44657e3..0000000
--- a/1.Vue/src/compiler/codegen/events.js
+++ /dev/null
@@ -1,190 +0,0 @@
-/* @flow */
-
-const fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function\s*(?:[\w$]+)?\s*\(/
-const fnInvokeRE = /\([^)]*?\);*$/
-const simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/
-
-// KeyboardEvent.keyCode aliases
-const keyCodes: { [key: string]: number | Array<number> } = {
-  esc: 27,
-  tab: 9,
-  enter: 13,
-  space: 32,
-  up: 38,
-  left: 37,
-  right: 39,
-  down: 40,
-  'delete': [8, 46]
-}
-
-// KeyboardEvent.key aliases
-const keyNames: { [key: string]: string | Array<string> } = {
-  // #7880: IE11 and Edge use `Esc` for Escape key name.
-  esc: ['Esc', 'Escape'],
-  tab: 'Tab',
-  enter: 'Enter',
-  // #9112: IE11 uses `Spacebar` for Space key name.
-  space: [' ', 'Spacebar'],
-  // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
-  up: ['Up', 'ArrowUp'],
-  left: ['Left', 'ArrowLeft'],
-  right: ['Right', 'ArrowRight'],
-  down: ['Down', 'ArrowDown'],
-  // #9112: IE11 uses `Del` for Delete key name.
-  'delete': ['Backspace', 'Delete', 'Del']
-}
-
-// #4868: modifiers that prevent the execution of the listener
-// need to explicitly return null so that we can determine whether to remove
-// the listener for .once
-const genGuard = condition => `if(${condition})return null;`
-
-const modifierCode: { [key: string]: string } = {
-  stop: '$event.stopPropagation();',
-  prevent: '$event.preventDefault();',
-  self: genGuard(`$event.target !== $event.currentTarget`),
-  ctrl: genGuard(`!$event.ctrlKey`),
-  shift: genGuard(`!$event.shiftKey`),
-  alt: genGuard(`!$event.altKey`),
-  meta: genGuard(`!$event.metaKey`),
-  left: genGuard(`'button' in $event && $event.button !== 0`),
-  middle: genGuard(`'button' in $event && $event.button !== 1`),
-  right: genGuard(`'button' in $event && $event.button !== 2`)
-}
-
-export function genHandlers (
-  events: ASTElementHandlers,
-  isNative: boolean
-): string {
-  const prefix = isNative ? 'nativeOn:' : 'on:'
-  let staticHandlers = ``
-  let dynamicHandlers = ``
-  for (const name in events) {
-    const handlerCode = genHandler(events[name])
-    if (events[name] && events[name].dynamic) {
-      dynamicHandlers += `${name},${handlerCode},`
-    } else {
-      staticHandlers += `"${name}":${handlerCode},`
-    }
-  }
-  staticHandlers = `{${staticHandlers.slice(0, -1)}}`
-  if (dynamicHandlers) {
-    return prefix + `_d(${staticHandlers},[${dynamicHandlers.slice(0, -1)}])`
-  } else {
-    return prefix + staticHandlers
-  }
-}
-
-// Generate handler code with binding params on Weex
-/* istanbul ignore next */
-function genWeexHandler (params: Array<any>, handlerCode: string) {
-  let innerHandlerCode = handlerCode
-  const exps = params.filter(exp => simplePathRE.test(exp) && exp !== '$event')
-  const bindings = exps.map(exp => ({ '@binding': exp }))
-  const args = exps.map((exp, i) => {
-    const key = `$_${i + 1}`
-    innerHandlerCode = innerHandlerCode.replace(exp, key)
-    return key
-  })
-  args.push('$event')
-  return '{\n' +
-    `handler:function(${args.join(',')}){${innerHandlerCode}},\n` +
-    `params:${JSON.stringify(bindings)}\n` +
-    '}'
-}
-
-function genHandler (handler: ASTElementHandler | Array<ASTElementHandler>): string {
-  if (!handler) {
-    return 'function(){}'
-  }
-
-  if (Array.isArray(handler)) {
-    return `[${handler.map(handler => genHandler(handler)).join(',')}]`
-  }
-
-  const isMethodPath = simplePathRE.test(handler.value)
-  const isFunctionExpression = fnExpRE.test(handler.value)
-  const isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''))
-
-  if (!handler.modifiers) {
-    if (isMethodPath || isFunctionExpression) {
-      return handler.value
-    }
-    /* istanbul ignore if */
-    if (__WEEX__ && handler.params) {
-      return genWeexHandler(handler.params, handler.value)
-    }
-    return `function($event){${
-      isFunctionInvocation ? `return ${handler.value}` : handler.value
-    }}` // inline statement
-  } else {
-    let code = ''
-    let genModifierCode = ''
-    const keys = []
-    for (const key in handler.modifiers) {
-      if (modifierCode[key]) {
-        genModifierCode += modifierCode[key]
-        // left/right
-        if (keyCodes[key]) {
-          keys.push(key)
-        }
-      } else if (key === 'exact') {
-        const modifiers: ASTModifiers = (handler.modifiers: any)
-        genModifierCode += genGuard(
-          ['ctrl', 'shift', 'alt', 'meta']
-            .filter(keyModifier => !modifiers[keyModifier])
-            .map(keyModifier => `$event.${keyModifier}Key`)
-            .join('||')
-        )
-      } else {
-        keys.push(key)
-      }
-    }
-    if (keys.length) {
-      code += genKeyFilter(keys)
-    }
-    // Make sure modifiers like prevent and stop get executed after key filtering
-    if (genModifierCode) {
-      code += genModifierCode
-    }
-    const handlerCode = isMethodPath
-      ? `return ${handler.value}($event)`
-      : isFunctionExpression
-        ? `return (${handler.value})($event)`
-        : isFunctionInvocation
-          ? `return ${handler.value}`
-          : handler.value
-    /* istanbul ignore if */
-    if (__WEEX__ && handler.params) {
-      return genWeexHandler(handler.params, code + handlerCode)
-    }
-    return `function($event){${code}${handlerCode}}`
-  }
-}
-
-function genKeyFilter (keys: Array<string>): string {
-  return (
-    // make sure the key filters only apply to KeyboardEvents
-    // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
-    // key events that do not have keyCode property...
-    `if(!$event.type.indexOf('key')&&` +
-    `${keys.map(genFilterCode).join('&&')})return null;`
-  )
-}
-
-function genFilterCode (key: string): string {
-  const keyVal = parseInt(key, 10)
-  if (keyVal) {
-    return `$event.keyCode!==${keyVal}`
-  }
-  const keyCode = keyCodes[key]
-  const keyName = keyNames[key]
-  return (
-    `_k($event.keyCode,` +
-    `${JSON.stringify(key)},` +
-    `${JSON.stringify(keyCode)},` +
-    `$event.key,` +
-    `${JSON.stringify(keyName)}` +
-    `)`
-  )
-}
diff --git a/1.Vue/src/compiler/codegen/index.js b/1.Vue/src/compiler/codegen/index.js
deleted file mode 100644
index c96b3a3..0000000
--- a/1.Vue/src/compiler/codegen/index.js
+++ /dev/null
@@ -1,618 +0,0 @@
-/* @flow */
-
-import { genHandlers } from './events'
-import baseDirectives from '../directives/index'
-import { camelize, no, extend } from 'shared/util'
-import { baseWarn, pluckModuleFunction } from '../helpers'
-import { emptySlotScopeToken } from '../parser/index'
-
-type TransformFunction = (el: ASTElement, code: string) => string;
-type DataGenFunction = (el: ASTElement) => string;
-type DirectiveFunction = (el: ASTElement, dir: ASTDirective, warn: Function) => boolean;
-
-export class CodegenState {
-  options: CompilerOptions;
-  warn: Function;
-  transforms: Array<TransformFunction>;
-  dataGenFns: Array<DataGenFunction>;
-  directives: { [key: string]: DirectiveFunction };
-  maybeComponent: (el: ASTElement) => boolean;
-  onceId: number;
-  staticRenderFns: Array<string>;
-  pre: boolean;
-
-  constructor (options: CompilerOptions) {
-    this.options = options
-    this.warn = options.warn || baseWarn
-    this.transforms = pluckModuleFunction(options.modules, 'transformCode')
-    this.dataGenFns = pluckModuleFunction(options.modules, 'genData')
-    this.directives = extend(extend({}, baseDirectives), options.directives)
-    const isReservedTag = options.isReservedTag || no
-    this.maybeComponent = (el: ASTElement) => !!el.component || !isReservedTag(el.tag)
-    this.onceId = 0
-    this.staticRenderFns = []
-    this.pre = false
-  }
-}
-
-export type CodegenResult = {
-  render: string,
-  staticRenderFns: Array<string>
-};
-
-export function generate (
-  ast: ASTElement | void,
-  options: CompilerOptions
-): CodegenResult {
-  const state = new CodegenState(options)
-  const code = ast ? genElement(ast, state) : '_c("div")'
-  return {
-    render: `with(this){return ${code}}`,
-    staticRenderFns: state.staticRenderFns
-  }
-}
-
-export function genElement (el: ASTElement, state: CodegenState): string {
-  if (el.parent) {
-    el.pre = el.pre || el.parent.pre
-  }
-
-  if (el.staticRoot && !el.staticProcessed) {
-    return genStatic(el, state)
-  } else if (el.once && !el.onceProcessed) {
-    return genOnce(el, state)
-  } else if (el.for && !el.forProcessed) {
-    return genFor(el, state)
-  } else if (el.if && !el.ifProcessed) {
-    return genIf(el, state)
-  } else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
-    return genChildren(el, state) || 'void 0'
-  } else if (el.tag === 'slot') {
-    return genSlot(el, state)
-  } else {
-    // component or element
-    let code
-    if (el.component) {
-      code = genComponent(el.component, el, state)
-    } else {
-      let data
-      if (!el.plain || (el.pre && state.maybeComponent(el))) {
-        data = genData(el, state)
-      }
-
-      const children = el.inlineTemplate ? null : genChildren(el, state, true)
-      code = `_c('${el.tag}'${
-        data ? `,${data}` : '' // data
-      }${
-        children ? `,${children}` : '' // children
-      })`
-    }
-    // module transforms
-    for (let i = 0; i < state.transforms.length; i++) {
-      code = state.transforms[i](el, code)
-    }
-    return code
-  }
-}
-
-// hoist static sub-trees out
-function genStatic (el: ASTElement, state: CodegenState): string {
-  el.staticProcessed = true
-  // Some elements (templates) need to behave differently inside of a v-pre
-  // node.  All pre nodes are static roots, so we can use this as a location to
-  // wrap a state change and reset it upon exiting the pre node.
-  const originalPreState = state.pre
-  if (el.pre) {
-    state.pre = el.pre
-  }
-  state.staticRenderFns.push(`with(this){return ${genElement(el, state)}}`)
-  state.pre = originalPreState
-  return `_m(${
-    state.staticRenderFns.length - 1
-  }${
-    el.staticInFor ? ',true' : ''
-  })`
-}
-
-// v-once
-function genOnce (el: ASTElement, state: CodegenState): string {
-  el.onceProcessed = true
-  if (el.if && !el.ifProcessed) {
-    return genIf(el, state)
-  } else if (el.staticInFor) {
-    let key = ''
-    let parent = el.parent
-    while (parent) {
-      if (parent.for) {
-        key = parent.key
-        break
-      }
-      parent = parent.parent
-    }
-    if (!key) {
-      process.env.NODE_ENV !== 'production' && state.warn(
-        `v-once can only be used inside v-for that is keyed. `,
-        el.rawAttrsMap['v-once']
-      )
-      return genElement(el, state)
-    }
-    return `_o(${genElement(el, state)},${state.onceId++},${key})`
-  } else {
-    return genStatic(el, state)
-  }
-}
-
-export function genIf (
-  el: any,
-  state: CodegenState,
-  altGen?: Function,
-  altEmpty?: string
-): string {
-  el.ifProcessed = true // avoid recursion
-  return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty)
-}
-
-function genIfConditions (
-  conditions: ASTIfConditions,
-  state: CodegenState,
-  altGen?: Function,
-  altEmpty?: string
-): string {
-  if (!conditions.length) {
-    return altEmpty || '_e()'
-  }
-
-  const condition = conditions.shift()
-  if (condition.exp) {
-    return `(${condition.exp})?${
-      genTernaryExp(condition.block)
-    }:${
-      genIfConditions(conditions, state, altGen, altEmpty)
-    }`
-  } else {
-    return `${genTernaryExp(condition.block)}`
-  }
-
-  // v-if with v-once should generate code like (a)?_m(0):_m(1)
-  function genTernaryExp (el) {
-    return altGen
-      ? altGen(el, state)
-      : el.once
-        ? genOnce(el, state)
-        : genElement(el, state)
-  }
-}
-
-export function genFor (
-  el: any,
-  state: CodegenState,
-  altGen?: Function,
-  altHelper?: string
-): string {
-  const exp = el.for
-  const alias = el.alias
-  const iterator1 = el.iterator1 ? `,${el.iterator1}` : ''
-  const iterator2 = el.iterator2 ? `,${el.iterator2}` : ''
-
-  if (process.env.NODE_ENV !== 'production' &&
-    state.maybeComponent(el) &&
-    el.tag !== 'slot' &&
-    el.tag !== 'template' &&
-    !el.key
-  ) {
-    state.warn(
-      `<${el.tag} v-for="${alias} in ${exp}">: component lists rendered with ` +
-      `v-for should have explicit keys. ` +
-      `See https://vuejs.org/guide/list.html#key for more info.`,
-      el.rawAttrsMap['v-for'],
-      true /* tip */
-    )
-  }
-
-  el.forProcessed = true // avoid recursion
-  return `${altHelper || '_l'}((${exp}),` +
-    `function(${alias}${iterator1}${iterator2}){` +
-      `return ${(altGen || genElement)(el, state)}` +
-    '})'
-}
-
-export function genData (el: ASTElement, state: CodegenState): string {
-  let data = '{'
-
-  // directives first.
-  // directives may mutate the el's other properties before they are generated.
-  const dirs = genDirectives(el, state)
-  if (dirs) data += dirs + ','
-
-  // key
-  if (el.key) {
-    data += `key:${el.key},`
-  }
-  // ref
-  if (el.ref) {
-    data += `ref:${el.ref},`
-  }
-  if (el.refInFor) {
-    data += `refInFor:true,`
-  }
-  // pre
-  if (el.pre) {
-    data += `pre:true,`
-  }
-  // record original tag name for components using "is" attribute
-  if (el.component) {
-    data += `tag:"${el.tag}",`
-  }
-  // module data generation functions
-  for (let i = 0; i < state.dataGenFns.length; i++) {
-    data += state.dataGenFns[i](el)
-  }
-  // attributes
-  if (el.attrs) {
-    data += `attrs:${genProps(el.attrs)},`
-  }
-  // DOM props
-  if (el.props) {
-    data += `domProps:${genProps(el.props)},`
-  }
-  // event handlers
-  if (el.events) {
-    data += `${genHandlers(el.events, false)},`
-  }
-  if (el.nativeEvents) {
-    data += `${genHandlers(el.nativeEvents, true)},`
-  }
-  // slot target
-  // only for non-scoped slots
-  if (el.slotTarget && !el.slotScope) {
-    data += `slot:${el.slotTarget},`
-  }
-  // scoped slots
-  if (el.scopedSlots) {
-    data += `${genScopedSlots(el, el.scopedSlots, state)},`
-  }
-  // component v-model
-  if (el.model) {
-    data += `model:{value:${
-      el.model.value
-    },callback:${
-      el.model.callback
-    },expression:${
-      el.model.expression
-    }},`
-  }
-  // inline-template
-  if (el.inlineTemplate) {
-    const inlineTemplate = genInlineTemplate(el, state)
-    if (inlineTemplate) {
-      data += `${inlineTemplate},`
-    }
-  }
-  data = data.replace(/,$/, '') + '}'
-  // v-bind dynamic argument wrap
-  // v-bind with dynamic arguments must be applied using the same v-bind object
-  // merge helper so that class/style/mustUseProp attrs are handled correctly.
-  if (el.dynamicAttrs) {
-    data = `_b(${data},"${el.tag}",${genProps(el.dynamicAttrs)})`
-  }
-  // v-bind data wrap
-  if (el.wrapData) {
-    data = el.wrapData(data)
-  }
-  // v-on data wrap
-  if (el.wrapListeners) {
-    data = el.wrapListeners(data)
-  }
-  return data
-}
-
-function genDirectives (el: ASTElement, state: CodegenState): string | void {
-  const dirs = el.directives
-  if (!dirs) return
-  let res = 'directives:['
-  let hasRuntime = false
-  let i, l, dir, needRuntime
-  for (i = 0, l = dirs.length; i < l; i++) {
-    dir = dirs[i]
-    needRuntime = true
-    const gen: DirectiveFunction = state.directives[dir.name]
-    if (gen) {
-      // compile-time directive that manipulates AST.
-      // returns true if it also needs a runtime counterpart.
-      needRuntime = !!gen(el, dir, state.warn)
-    }
-    if (needRuntime) {
-      hasRuntime = true
-      res += `{name:"${dir.name}",rawName:"${dir.rawName}"${
-        dir.value ? `,value:(${dir.value}),expression:${JSON.stringify(dir.value)}` : ''
-      }${
-        dir.arg ? `,arg:${dir.isDynamicArg ? dir.arg : `"${dir.arg}"`}` : ''
-      }${
-        dir.modifiers ? `,modifiers:${JSON.stringify(dir.modifiers)}` : ''
-      }},`
-    }
-  }
-  if (hasRuntime) {
-    return res.slice(0, -1) + ']'
-  }
-}
-
-function genInlineTemplate (el: ASTElement, state: CodegenState): ?string {
-  const ast = el.children[0]
-  if (process.env.NODE_ENV !== 'production' && (
-    el.children.length !== 1 || ast.type !== 1
-  )) {
-    state.warn(
-      'Inline-template components must have exactly one child element.',
-      { start: el.start }
-    )
-  }
-  if (ast && ast.type === 1) {
-    const inlineRenderFns = generate(ast, state.options)
-    return `inlineTemplate:{render:function(){${
-      inlineRenderFns.render
-    }},staticRenderFns:[${
-      inlineRenderFns.staticRenderFns.map(code => `function(){${code}}`).join(',')
-    }]}`
-  }
-}
-
-function genScopedSlots (
-  el: ASTElement,
-  slots: { [key: string]: ASTElement },
-  state: CodegenState
-): string {
-  // by default scoped slots are considered "stable", this allows child
-  // components with only scoped slots to skip forced updates from parent.
-  // but in some cases we have to bail-out of this optimization
-  // for example if the slot contains dynamic names, has v-if or v-for on them...
-  let needsForceUpdate = el.for || Object.keys(slots).some(key => {
-    const slot = slots[key]
-    return (
-      slot.slotTargetDynamic ||
-      slot.if ||
-      slot.for ||
-      containsSlotChild(slot) // is passing down slot from parent which may be dynamic
-    )
-  })
-
-  // #9534: if a component with scoped slots is inside a conditional branch,
-  // it's possible for the same component to be reused but with different
-  // compiled slot content. To avoid that, we generate a unique key based on
-  // the generated code of all the slot contents.
-  let needsKey = !!el.if
-
-  // OR when it is inside another scoped slot or v-for (the reactivity may be
-  // disconnected due to the intermediate scope variable)
-  // #9438, #9506
-  // TODO: this can be further optimized by properly analyzing in-scope bindings
-  // and skip force updating ones that do not actually use scope variables.
-  if (!needsForceUpdate) {
-    let parent = el.parent
-    while (parent) {
-      if (
-        (parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
-        parent.for
-      ) {
-        needsForceUpdate = true
-        break
-      }
-      if (parent.if) {
-        needsKey = true
-      }
-      parent = parent.parent
-    }
-  }
-
-  const generatedSlots = Object.keys(slots)
-    .map(key => genScopedSlot(slots[key], state))
-    .join(',')
-
-  return `scopedSlots:_u([${generatedSlots}]${
-    needsForceUpdate ? `,null,true` : ``
-  }${
-    !needsForceUpdate && needsKey ? `,null,false,${hash(generatedSlots)}` : ``
-  })`
-}
-
-function hash(str) {
-  let hash = 5381
-  let i = str.length
-  while(i) {
-    hash = (hash * 33) ^ str.charCodeAt(--i)
-  }
-  return hash >>> 0
-}
-
-function containsSlotChild (el: ASTNode): boolean {
-  if (el.type === 1) {
-    if (el.tag === 'slot') {
-      return true
-    }
-    return el.children.some(containsSlotChild)
-  }
-  return false
-}
-
-function genScopedSlot (
-  el: ASTElement,
-  state: CodegenState
-): string {
-  const isLegacySyntax = el.attrsMap['slot-scope']
-  if (el.if && !el.ifProcessed && !isLegacySyntax) {
-    return genIf(el, state, genScopedSlot, `null`)
-  }
-  if (el.for && !el.forProcessed) {
-    return genFor(el, state, genScopedSlot)
-  }
-  const slotScope = el.slotScope === emptySlotScopeToken
-    ? ``
-    : String(el.slotScope)
-  const fn = `function(${slotScope}){` +
-    `return ${el.tag === 'template'
-      ? el.if && isLegacySyntax
-        ? `(${el.if})?${genChildren(el, state) || 'undefined'}:undefined`
-        : genChildren(el, state) || 'undefined'
-      : genElement(el, state)
-    }}`
-  // reverse proxy v-slot without scope on this.$slots
-  const reverseProxy = slotScope ? `` : `,proxy:true`
-  return `{key:${el.slotTarget || `"default"`},fn:${fn}${reverseProxy}}`
-}
-
-export function genChildren (
-  el: ASTElement,
-  state: CodegenState,
-  checkSkip?: boolean,
-  altGenElement?: Function,
-  altGenNode?: Function
-): string | void {
-  const children = el.children
-  if (children.length) {
-    const el: any = children[0]
-    // optimize single v-for
-    if (children.length === 1 &&
-      el.for &&
-      el.tag !== 'template' &&
-      el.tag !== 'slot'
-    ) {
-      const normalizationType = checkSkip
-        ? state.maybeComponent(el) ? `,1` : `,0`
-        : ``
-      return `${(altGenElement || genElement)(el, state)}${normalizationType}`
-    }
-    const normalizationType = checkSkip
-      ? getNormalizationType(children, state.maybeComponent)
-      : 0
-    const gen = altGenNode || genNode
-    return `[${children.map(c => gen(c, state)).join(',')}]${
-      normalizationType ? `,${normalizationType}` : ''
-    }`
-  }
-}
-
-// determine the normalization needed for the children array.
-// 0: no normalization needed
-// 1: simple normalization needed (possible 1-level deep nested array)
-// 2: full normalization needed
-function getNormalizationType (
-  children: Array<ASTNode>,
-  maybeComponent: (el: ASTElement) => boolean
-): number {
-  let res = 0
-  for (let i = 0; i < children.length; i++) {
-    const el: ASTNode = children[i]
-    if (el.type !== 1) {
-      continue
-    }
-    if (needsNormalization(el) ||
-        (el.ifConditions && el.ifConditions.some(c => needsNormalization(c.block)))) {
-      res = 2
-      break
-    }
-    if (maybeComponent(el) ||
-        (el.ifConditions && el.ifConditions.some(c => maybeComponent(c.block)))) {
-      res = 1
-    }
-  }
-  return res
-}
-
-function needsNormalization (el: ASTElement): boolean {
-  return el.for !== undefined || el.tag === 'template' || el.tag === 'slot'
-}
-
-function genNode (node: ASTNode, state: CodegenState): string {
-  if (node.type === 1) {
-    return genElement(node, state)
-  } else if (node.type === 3 && node.isComment) {
-    return genComment(node)
-  } else {
-    return genText(node)
-  }
-}
-
-export function genText (text: ASTText | ASTExpression): string {
-  return `_v(${text.type === 2
-    ? text.expression // no need for () because already wrapped in _s()
-    : transformSpecialNewlines(JSON.stringify(text.text))
-  })`
-}
-
-export function genComment (comment: ASTText): string {
-  return `_e(${JSON.stringify(comment.text)})`
-}
-
-function genSlot (el: ASTElement, state: CodegenState): string {
-  const slotName = el.slotName || '"default"'
-  const children = genChildren(el, state)
-  let res = `_t(${slotName}${children ? `,${children}` : ''}`
-  const attrs = el.attrs || el.dynamicAttrs
-    ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(attr => ({
-        // slot props are camelized
-        name: camelize(attr.name),
-        value: attr.value,
-        dynamic: attr.dynamic
-      })))
-    : null
-  const bind = el.attrsMap['v-bind']
-  if ((attrs || bind) && !children) {
-    res += `,null`
-  }
-  if (attrs) {
-    res += `,${attrs}`
-  }
-  if (bind) {
-    res += `${attrs ? '' : ',null'},${bind}`
-  }
-  return res + ')'
-}
-
-// componentName is el.component, take it as argument to shun flow's pessimistic refinement
-function genComponent (
-  componentName: string,
-  el: ASTElement,
-  state: CodegenState
-): string {
-  const children = el.inlineTemplate ? null : genChildren(el, state, true)
-  return `_c(${componentName},${genData(el, state)}${
-    children ? `,${children}` : ''
-  })`
-}
-
-function genProps (props: Array<ASTAttr>): string {
-  let staticProps = ``
-  let dynamicProps = ``
-  for (let i = 0; i < props.length; i++) {
-    const prop = props[i]
-    const value = __WEEX__
-      ? generateValue(prop.value)
-      : transformSpecialNewlines(prop.value)
-    if (prop.dynamic) {
-      dynamicProps += `${prop.name},${value},`
-    } else {
-      staticProps += `"${prop.name}":${value},`
-    }
-  }
-  staticProps = `{${staticProps.slice(0, -1)}}`
-  if (dynamicProps) {
-    return `_d(${staticProps},[${dynamicProps.slice(0, -1)}])`
-  } else {
-    return staticProps
-  }
-}
-
-/* istanbul ignore next */
-function generateValue (value) {
-  if (typeof value === 'string') {
-    return transformSpecialNewlines(value)
-  }
-  return JSON.stringify(value)
-}
-
-// #3895, #4268
-function transformSpecialNewlines (text: string): string {
-  return text
-    .replace(/\u2028/g, '\\u2028')
-    .replace(/\u2029/g, '\\u2029')
-}
diff --git a/1.Vue/src/compiler/create-compiler.js b/1.Vue/src/compiler/create-compiler.js
deleted file mode 100644
index 67d2057..0000000
--- a/1.Vue/src/compiler/create-compiler.js
+++ /dev/null
@@ -1,75 +0,0 @@
-/* @flow */
-
-import { extend } from 'shared/util'
-import { detectErrors } from './error-detector'
-import { createCompileToFunctionFn } from './to-function'
-
-export function createCompilerCreator (baseCompile: Function): Function {
-  return function createCompiler (baseOptions: CompilerOptions) {
-    function compile (
-      template: string,
-      options?: CompilerOptions
-    ): CompiledResult {
-      const finalOptions = Object.create(baseOptions)
-      const errors = []
-      const tips = []
-
-      let warn = (msg, range, tip) => {
-        (tip ? tips : errors).push(msg)
-      }
-
-      if (options) {
-        if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
-          // $flow-disable-line
-          const leadingSpaceLength = template.match(/^\s*/)[0].length
-
-          warn = (msg, range, tip) => {
-            const data: WarningMessage = { msg }
-            if (range) {
-              if (range.start != null) {
-                data.start = range.start + leadingSpaceLength
-              }
-              if (range.end != null) {
-                data.end = range.end + leadingSpaceLength
-              }
-            }
-            (tip ? tips : errors).push(data)
-          }
-        }
-        // merge custom modules
-        if (options.modules) {
-          finalOptions.modules =
-            (baseOptions.modules || []).concat(options.modules)
-        }
-        // merge custom directives
-        if (options.directives) {
-          finalOptions.directives = extend(
-            Object.create(baseOptions.directives || null),
-            options.directives
-          )
-        }
-        // copy other options
-        for (const key in options) {
-          if (key !== 'modules' && key !== 'directives') {
-            finalOptions[key] = options[key]
-          }
-        }
-      }
-
-      finalOptions.warn = warn
-
-      const compiled = baseCompile(template.trim(), finalOptions)
-      if (process.env.NODE_ENV !== 'production') {
-        detectErrors(compiled.ast, warn)
-      }
-      compiled.errors = errors
-      compiled.tips = tips
-      return compiled
-    }
-
-    return {
-      compile,
-      compileToFunctions: createCompileToFunctionFn(compile)
-    }
-  }
-}
diff --git a/1.Vue/src/compiler/directives/bind.js b/1.Vue/src/compiler/directives/bind.js
deleted file mode 100644
index e103572..0000000
--- a/1.Vue/src/compiler/directives/bind.js
+++ /dev/null
@@ -1,11 +0,0 @@
-/* @flow */
-
-export default function bind (el: ASTElement, dir: ASTDirective) {
-  el.wrapData = (code: string) => {
-    return `_b(${code},'${el.tag}',${dir.value},${
-      dir.modifiers && dir.modifiers.prop ? 'true' : 'false'
-    }${
-      dir.modifiers && dir.modifiers.sync ? ',true' : ''
-    })`
-  }
-}
diff --git a/1.Vue/src/compiler/directives/index.js b/1.Vue/src/compiler/directives/index.js
deleted file mode 100644
index 8f4342c..0000000
--- a/1.Vue/src/compiler/directives/index.js
+++ /dev/null
@@ -1,11 +0,0 @@
-/* @flow */
-
-import on from './on'
-import bind from './bind'
-import { noop } from 'shared/util'
-
-export default {
-  on,
-  bind,
-  cloak: noop
-}
diff --git a/1.Vue/src/compiler/directives/model.js b/1.Vue/src/compiler/directives/model.js
deleted file mode 100644
index c7a4c09..0000000
--- a/1.Vue/src/compiler/directives/model.js
+++ /dev/null
@@ -1,148 +0,0 @@
-/* @flow */
-
-/**
- * Cross-platform code generation for component v-model
- */
-export function genComponentModel (
-  el: ASTElement,
-  value: string,
-  modifiers: ?ASTModifiers
-): ?boolean {
-  const { number, trim } = modifiers || {}
-
-  const baseValueExpression = '$$v'
-  let valueExpression = baseValueExpression
-  if (trim) {
-    valueExpression =
-      `(typeof ${baseValueExpression} === 'string'` +
-      `? ${baseValueExpression}.trim()` +
-      `: ${baseValueExpression})`
-  }
-  if (number) {
-    valueExpression = `_n(${valueExpression})`
-  }
-  const assignment = genAssignmentCode(value, valueExpression)
-
-  el.model = {
-    value: `(${value})`,
-    expression: JSON.stringify(value),
-    callback: `function (${baseValueExpression}) {${assignment}}`
-  }
-}
-
-/**
- * Cross-platform codegen helper for generating v-model value assignment code.
- */
-export function genAssignmentCode (
-  value: string,
-  assignment: string
-): string {
-  const res = parseModel(value)
-  if (res.key === null) {
-    return `${value}=${assignment}`
-  } else {
-    return `$set(${res.exp}, ${res.key}, ${assignment})`
-  }
-}
-
-/**
- * Parse a v-model expression into a base path and a final key segment.
- * Handles both dot-path and possible square brackets.
- *
- * Possible cases:
- *
- * - test
- * - test[key]
- * - test[test1[key]]
- * - test["a"][key]
- * - xxx.test[a[a].test1[key]]
- * - test.xxx.a["asa"][test1[key]]
- *
- */
-
-let len, str, chr, index, expressionPos, expressionEndPos
-
-type ModelParseResult = {
-  exp: string,
-  key: string | null
-}
-
-export function parseModel (val: string): ModelParseResult {
-  // Fix https://github.com/vuejs/vue/pull/7730
-  // allow v-model="obj.val " (trailing whitespace)
-  val = val.trim()
-  len = val.length
-
-  if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
-    index = val.lastIndexOf('.')
-    if (index > -1) {
-      return {
-        exp: val.slice(0, index),
-        key: '"' + val.slice(index + 1) + '"'
-      }
-    } else {
-      return {
-        exp: val,
-        key: null
-      }
-    }
-  }
-
-  str = val
-  index = expressionPos = expressionEndPos = 0
-
-  while (!eof()) {
-    chr = next()
-    /* istanbul ignore if */
-    if (isStringStart(chr)) {
-      parseString(chr)
-    } else if (chr === 0x5B) {
-      parseBracket(chr)
-    }
-  }
-
-  return {
-    exp: val.slice(0, expressionPos),
-    key: val.slice(expressionPos + 1, expressionEndPos)
-  }
-}
-
-function next (): number {
-  return str.charCodeAt(++index)
-}
-
-function eof (): boolean {
-  return index >= len
-}
-
-function isStringStart (chr: number): boolean {
-  return chr === 0x22 || chr === 0x27
-}
-
-function parseBracket (chr: number): void {
-  let inBracket = 1
-  expressionPos = index
-  while (!eof()) {
-    chr = next()
-    if (isStringStart(chr)) {
-      parseString(chr)
-      continue
-    }
-    if (chr === 0x5B) inBracket++
-    if (chr === 0x5D) inBracket--
-    if (inBracket === 0) {
-      expressionEndPos = index
-      break
-    }
-  }
-}
-
-function parseString (chr: number): void {
-  const stringQuote = chr
-  while (!eof()) {
-    chr = next()
-    if (chr === stringQuote) {
-      break
-    }
-  }
-}
diff --git a/1.Vue/src/compiler/directives/on.js b/1.Vue/src/compiler/directives/on.js
deleted file mode 100644
index 893a678..0000000
--- a/1.Vue/src/compiler/directives/on.js
+++ /dev/null
@@ -1,10 +0,0 @@
-/* @flow */
-
-import { warn } from 'core/util/index'
-
-export default function on (el: ASTElement, dir: ASTDirective) {
-  if (process.env.NODE_ENV !== 'production' && dir.modifiers) {
-    warn(`v-on without argument does not support modifiers.`)
-  }
-  el.wrapListeners = (code: string) => `_g(${code},${dir.value})`
-}
diff --git a/1.Vue/src/compiler/error-detector.js b/1.Vue/src/compiler/error-detector.js
deleted file mode 100644
index 22c3b75..0000000
--- a/1.Vue/src/compiler/error-detector.js
+++ /dev/null
@@ -1,113 +0,0 @@
-/* @flow */
-
-import { dirRE, onRE } from './parser/index'
-
-type Range = { start?: number, end?: number };
-
-// these keywords should not appear inside expressions, but operators like
-// typeof, instanceof and in are allowed
-const prohibitedKeywordRE = new RegExp('\\b' + (
-  'do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
-  'super,throw,while,yield,delete,export,import,return,switch,default,' +
-  'extends,finally,continue,debugger,function,arguments'
-).split(',').join('\\b|\\b') + '\\b')
-
-// these unary operators should not be used as property/method names
-const unaryOperatorsRE = new RegExp('\\b' + (
-  'delete,typeof,void'
-).split(',').join('\\s*\\([^\\)]*\\)|\\b') + '\\s*\\([^\\)]*\\)')
-
-// strip strings in expressions
-const stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g
-
-// detect problematic expressions in a template
-export function detectErrors (ast: ?ASTNode, warn: Function) {
-  if (ast) {
-    checkNode(ast, warn)
-  }
-}
-
-function checkNode (node: ASTNode, warn: Function) {
-  if (node.type === 1) {
-    for (const name in node.attrsMap) {
-      if (dirRE.test(name)) {
-        const value = node.attrsMap[name]
-        if (value) {
-          const range = node.rawAttrsMap[name]
-          if (name === 'v-for') {
-            checkFor(node, `v-for="${value}"`, warn, range)
-          } else if (onRE.test(name)) {
-            checkEvent(value, `${name}="${value}"`, warn, range)
-          } else {
-            checkExpression(value, `${name}="${value}"`, warn, range)
-          }
-        }
-      }
-    }
-    if (node.children) {
-      for (let i = 0; i < node.children.length; i++) {
-        checkNode(node.children[i], warn)
-      }
-    }
-  } else if (node.type === 2) {
-    checkExpression(node.expression, node.text, warn, node)
-  }
-}
-
-function checkEvent (exp: string, text: string, warn: Function, range?: Range) {
-  const stipped = exp.replace(stripStringRE, '')
-  const keywordMatch: any = stipped.match(unaryOperatorsRE)
-  if (keywordMatch && stipped.charAt(keywordMatch.index - 1) !== '$') {
-    warn(
-      `avoid using JavaScript unary operator as property name: ` +
-      `"${keywordMatch[0]}" in expression ${text.trim()}`,
-      range
-    )
-  }
-  checkExpression(exp, text, warn, range)
-}
-
-function checkFor (node: ASTElement, text: string, warn: Function, range?: Range) {
-  checkExpression(node.for || '', text, warn, range)
-  checkIdentifier(node.alias, 'v-for alias', text, warn, range)
-  checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range)
-  checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range)
-}
-
-function checkIdentifier (
-  ident: ?string,
-  type: string,
-  text: string,
-  warn: Function,
-  range?: Range
-) {
-  if (typeof ident === 'string') {
-    try {
-      new Function(`var ${ident}=_`)
-    } catch (e) {
-      warn(`invalid ${type} "${ident}" in expression: ${text.trim()}`, range)
-    }
-  }
-}
-
-function checkExpression (exp: string, text: string, warn: Function, range?: Range) {
-  try {
-    new Function(`return ${exp}`)
-  } catch (e) {
-    const keywordMatch = exp.replace(stripStringRE, '').match(prohibitedKeywordRE)
-    if (keywordMatch) {
-      warn(
-        `avoid using JavaScript keyword as property name: ` +
-        `"${keywordMatch[0]}"\n  Raw expression: ${text.trim()}`,
-        range
-      )
-    } else {
-      warn(
-        `invalid expression: ${e.message} in\n\n` +
-        `    ${exp}\n\n` +
-        `  Raw expression: ${text.trim()}\n`,
-        range
-      )
-    }
-  }
-}
diff --git a/1.Vue/src/compiler/helpers.js b/1.Vue/src/compiler/helpers.js
deleted file mode 100644
index 7231d68..0000000
--- a/1.Vue/src/compiler/helpers.js
+++ /dev/null
@@ -1,231 +0,0 @@
-/* @flow */
-
-import { emptyObject } from 'shared/util'
-import { parseFilters } from './parser/filter-parser'
-
-type Range = { start?: number, end?: number };
-
-/* eslint-disable no-unused-vars */
-export function baseWarn (msg: string, range?: Range) {
-  console.error(`[Vue compiler]: ${msg}`)
-}
-/* eslint-enable no-unused-vars */
-
-export function pluckModuleFunction<F: Function> (
-  modules: ?Array<Object>,
-  key: string
-): Array<F> {
-  return modules
-    ? modules.map(m => m[key]).filter(_ => _)
-    : []
-}
-
-export function addProp (el: ASTElement, name: string, value: string, range?: Range, dynamic?: boolean) {
-  (el.props || (el.props = [])).push(rangeSetItem({ name, value, dynamic }, range))
-  el.plain = false
-}
-
-export function addAttr (el: ASTElement, name: string, value: any, range?: Range, dynamic?: boolean) {
-  const attrs = dynamic
-    ? (el.dynamicAttrs || (el.dynamicAttrs = []))
-    : (el.attrs || (el.attrs = []))
-  attrs.push(rangeSetItem({ name, value, dynamic }, range))
-  el.plain = false
-}
-
-// add a raw attr (use this in preTransforms)
-export function addRawAttr (el: ASTElement, name: string, value: any, range?: Range) {
-  el.attrsMap[name] = value
-  el.attrsList.push(rangeSetItem({ name, value }, range))
-}
-
-export function addDirective (
-  el: ASTElement,
-  name: string,
-  rawName: string,
-  value: string,
-  arg: ?string,
-  isDynamicArg: boolean,
-  modifiers: ?ASTModifiers,
-  range?: Range
-) {
-  (el.directives || (el.directives = [])).push(rangeSetItem({
-    name,
-    rawName,
-    value,
-    arg,
-    isDynamicArg,
-    modifiers
-  }, range))
-  el.plain = false
-}
-
-function prependModifierMarker (symbol: string, name: string, dynamic?: boolean): string {
-  return dynamic
-    ? `_p(${name},"${symbol}")`
-    : symbol + name // mark the event as captured
-}
-
-export function addHandler (
-  el: ASTElement,
-  name: string,
-  value: string,
-  modifiers: ?ASTModifiers,
-  important?: boolean,
-  warn?: ?Function,
-  range?: Range,
-  dynamic?: boolean
-) {
-  modifiers = modifiers || emptyObject
-  // warn prevent and passive modifier
-  /* istanbul ignore if */
-  if (
-    process.env.NODE_ENV !== 'production' && warn &&
-    modifiers.prevent && modifiers.passive
-  ) {
-    warn(
-      'passive and prevent can\'t be used together. ' +
-      'Passive handler can\'t prevent default event.',
-      range
-    )
-  }
-
-  // normalize click.right and click.middle since they don't actually fire
-  // this is technically browser-specific, but at least for now browsers are
-  // the only target envs that have right/middle clicks.
-  if (modifiers.right) {
-    if (dynamic) {
-      name = `(${name})==='click'?'contextmenu':(${name})`
-    } else if (name === 'click') {
-      name = 'contextmenu'
-      delete modifiers.right
-    }
-  } else if (modifiers.middle) {
-    if (dynamic) {
-      name = `(${name})==='click'?'mouseup':(${name})`
-    } else if (name === 'click') {
-      name = 'mouseup'
-    }
-  }
-
-  // check capture modifier
-  if (modifiers.capture) {
-    delete modifiers.capture
-    name = prependModifierMarker('!', name, dynamic)
-  }
-  if (modifiers.once) {
-    delete modifiers.once
-    name = prependModifierMarker('~', name, dynamic)
-  }
-  /* istanbul ignore if */
-  if (modifiers.passive) {
-    delete modifiers.passive
-    name = prependModifierMarker('&', name, dynamic)
-  }
-
-  let events
-  if (modifiers.native) {
-    delete modifiers.native
-    events = el.nativeEvents || (el.nativeEvents = {})
-  } else {
-    events = el.events || (el.events = {})
-  }
-
-  const newHandler: any = rangeSetItem({ value: value.trim(), dynamic }, range)
-  if (modifiers !== emptyObject) {
-    newHandler.modifiers = modifiers
-  }
-
-  const 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
-  }
-
-  el.plain = false
-}
-
-export function getRawBindingAttr (
-  el: ASTElement,
-  name: string
-) {
-  return el.rawAttrsMap[':' + name] ||
-    el.rawAttrsMap['v-bind:' + name] ||
-    el.rawAttrsMap[name]
-}
-
-export function getBindingAttr (
-  el: ASTElement,
-  name: string,
-  getStatic?: boolean
-): ?string {
-  const dynamicValue =
-    getAndRemoveAttr(el, ':' + name) ||
-    getAndRemoveAttr(el, 'v-bind:' + name)
-  if (dynamicValue != null) {
-    return parseFilters(dynamicValue)
-  } else if (getStatic !== false) {
-    const staticValue = getAndRemoveAttr(el, name)
-    if (staticValue != null) {
-      return JSON.stringify(staticValue)
-    }
-  }
-}
-
-// note: this only removes the attr from the Array (attrsList) so that it
-// doesn't get processed by processAttrs.
-// By default it does NOT remove it from the map (attrsMap) because the map is
-// needed during codegen.
-export function getAndRemoveAttr (
-  el: ASTElement,
-  name: string,
-  removeFromMap?: boolean
-): ?string {
-  let val
-  if ((val = el.attrsMap[name]) != null) {
-    const list = el.attrsList
-    for (let i = 0, l = list.length; i < l; i++) {
-      if (list[i].name === name) {
-        list.splice(i, 1)
-        break
-      }
-    }
-  }
-  if (removeFromMap) {
-    delete el.attrsMap[name]
-  }
-  return val
-}
-
-export function getAndRemoveAttrByRegex (
-  el: ASTElement,
-  name: RegExp
-) {
-  const list = el.attrsList
-  for (let i = 0, l = list.length; i < l; i++) {
-    const attr = list[i]
-    if (name.test(attr.name)) {
-      list.splice(i, 1)
-      return attr
-    }
-  }
-}
-
-function rangeSetItem (
-  item: any,
-  range?: { start?: number, end?: number }
-) {
-  if (range) {
-    if (range.start != null) {
-      item.start = range.start
-    }
-    if (range.end != null) {
-      item.end = range.end
-    }
-  }
-  return item
-}
diff --git a/1.Vue/src/compiler/index.js b/1.Vue/src/compiler/index.js
deleted file mode 100644
index 56b54fd..0000000
--- a/1.Vue/src/compiler/index.js
+++ /dev/null
@@ -1,25 +0,0 @@
-/* @flow */
-
-import { parse } from './parser/index'
-import { optimize } from './optimizer'
-import { generate } from './codegen/index'
-import { createCompilerCreator } from './create-compiler'
-
-// `createCompilerCreator` allows creating compilers that use alternative
-// parser/optimizer/codegen, e.g the SSR optimizing compiler.
-// Here we just export a default compiler using the default parts.
-export const createCompiler = createCompilerCreator(function baseCompile (
-  template: string,
-  options: CompilerOptions
-): CompiledResult {
-  const ast = parse(template.trim(), options)
-  if (options.optimize !== false) {
-    optimize(ast, options)
-  }
-  const code = generate(ast, options)
-  return {
-    ast,
-    render: code.render,
-    staticRenderFns: code.staticRenderFns
-  }
-})
diff --git a/1.Vue/src/compiler/optimizer.js b/1.Vue/src/compiler/optimizer.js
deleted file mode 100644
index 5f56e74..0000000
--- a/1.Vue/src/compiler/optimizer.js
+++ /dev/null
@@ -1,128 +0,0 @@
-/* @flow */
-
-import { makeMap, isBuiltInTag, cached, no } from 'shared/util'
-
-let isStaticKey
-let isPlatformReservedTag
-
-const genStaticKeysCached = cached(genStaticKeys)
-
-/**
- * Goal of the optimizer: walk the generated template AST tree
- * and detect sub-trees that are purely static, i.e. parts of
- * the DOM that never needs to change.
- *
- * Once we detect these sub-trees, we can:
- *
- * 1. Hoist them into constants, so that we no longer need to
- *    create fresh nodes for them on each re-render;
- * 2. Completely skip them in the patching process.
- */
-export function optimize (root: ?ASTElement, options: CompilerOptions) {
-  if (!root) return
-  isStaticKey = genStaticKeysCached(options.staticKeys || '')
-  isPlatformReservedTag = options.isReservedTag || no
-  // first pass: mark all non-static nodes.
-  markStatic(root)
-  // second pass: mark static roots.
-  markStaticRoots(root, false)
-}
-
-function genStaticKeys (keys: string): Function {
-  return makeMap(
-    'type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap' +
-    (keys ? ',' + keys : '')
-  )
-}
-
-function markStatic (node: ASTNode) {
-  node.static = isStatic(node)
-  if (node.type === 1) {
-    // do not make component slot content static. this avoids
-    // 1. components not able to mutate slot nodes
-    // 2. static slot content fails for hot-reloading
-    if (
-      !isPlatformReservedTag(node.tag) &&
-      node.tag !== 'slot' &&
-      node.attrsMap['inline-template'] == null
-    ) {
-      return
-    }
-    for (let i = 0, l = node.children.length; i < l; i++) {
-      const child = node.children[i]
-      markStatic(child)
-      if (!child.static) {
-        node.static = false
-      }
-    }
-    if (node.ifConditions) {
-      for (let i = 1, l = node.ifConditions.length; i < l; i++) {
-        const block = node.ifConditions[i].block
-        markStatic(block)
-        if (!block.static) {
-          node.static = false
-        }
-      }
-    }
-  }
-}
-
-function markStaticRoots (node: ASTNode, isInFor: boolean) {
-  if (node.type === 1) {
-    if (node.static || node.once) {
-      node.staticInFor = isInFor
-    }
-    // For a node to qualify as a static root, it should have children that
-    // are not just static text. Otherwise the cost of hoisting out will
-    // outweigh the benefits and it's better off to just always render it fresh.
-    if (node.static && node.children.length && !(
-      node.children.length === 1 &&
-      node.children[0].type === 3
-    )) {
-      node.staticRoot = true
-      return
-    } else {
-      node.staticRoot = false
-    }
-    if (node.children) {
-      for (let i = 0, l = node.children.length; i < l; i++) {
-        markStaticRoots(node.children[i], isInFor || !!node.for)
-      }
-    }
-    if (node.ifConditions) {
-      for (let i = 1, l = node.ifConditions.length; i < l; i++) {
-        markStaticRoots(node.ifConditions[i].block, isInFor)
-      }
-    }
-  }
-}
-
-function isStatic (node: ASTNode): boolean {
-  if (node.type === 2) { // expression
-    return false
-  }
-  if (node.type === 3) { // text
-    return true
-  }
-  return !!(node.pre || (
-    !node.hasBindings && // no dynamic bindings
-    !node.if && !node.for && // not v-if or v-for or v-else
-    !isBuiltInTag(node.tag) && // not a built-in
-    isPlatformReservedTag(node.tag) && // not a component
-    !isDirectChildOfTemplateFor(node) &&
-    Object.keys(node).every(isStaticKey)
-  ))
-}
-
-function isDirectChildOfTemplateFor (node: ASTElement): boolean {
-  while (node.parent) {
-    node = node.parent
-    if (node.tag !== 'template') {
-      return false
-    }
-    if (node.for) {
-      return true
-    }
-  }
-  return false
-}
diff --git a/1.Vue/src/compiler/parser/entity-decoder.js b/1.Vue/src/compiler/parser/entity-decoder.js
deleted file mode 100644
index 2836294..0000000
--- a/1.Vue/src/compiler/parser/entity-decoder.js
+++ /dev/null
@@ -1,11 +0,0 @@
-/* @flow */
-
-let decoder
-
-export default {
-  decode (html: string): string {
-    decoder = decoder || document.createElement('div')
-    decoder.innerHTML = html
-    return decoder.textContent
-  }
-}
diff --git a/1.Vue/src/compiler/parser/filter-parser.js b/1.Vue/src/compiler/parser/filter-parser.js
deleted file mode 100644
index 10939d3..0000000
--- a/1.Vue/src/compiler/parser/filter-parser.js
+++ /dev/null
@@ -1,97 +0,0 @@
-/* @flow */
-
-const validDivisionCharRE = /[\w).+\-_$\]]/
-
-export function parseFilters (exp: string): string {
-  let inSingle = false
-  let inDouble = false
-  let inTemplateString = false
-  let inRegex = false
-  let curly = 0
-  let square = 0
-  let paren = 0
-  let lastFilterIndex = 0
-  let 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) { // /
-        let j = i - 1
-        let p
-        // 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: string, filter: string): string {
-  const i = filter.indexOf('(')
-  if (i < 0) {
-    // _f: resolveFilter
-    return `_f("${filter}")(${exp})`
-  } else {
-    const name = filter.slice(0, i)
-    const args = filter.slice(i + 1)
-    return `_f("${name}")(${exp}${args !== ')' ? ',' + args : args}`
-  }
-}
diff --git a/1.Vue/src/compiler/parser/html-parser.js b/1.Vue/src/compiler/parser/html-parser.js
deleted file mode 100644
index f93c098..0000000
--- a/1.Vue/src/compiler/parser/html-parser.js
+++ /dev/null
@@ -1,306 +0,0 @@
-/**
- * Not type-checking this file because it's mostly vendor code.
- */
-
-/*!
- * HTML Parser By John Resig (ejohn.org)
- * Modified by Juriy "kangax" Zaytsev
- * Original code by Erik Arvidsson, Mozilla Public License
- * http://erik.eae.net/simplehtmlparser/simplehtmlparser.js
- */
-
-import { makeMap, no } from 'shared/util'
-import { isNonPhrasingTag } from 'web/compiler/util'
-import { unicodeRegExp } from 'core/util/lang'
-
-// Regular Expressions for parsing tags and attributes
-const attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/
-const dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/
-const ncname = `[a-zA-Z_][\\-\\.0-9_a-zA-Z${unicodeRegExp.source}]*`
-const qnameCapture = `((?:${ncname}\\:)?${ncname})`
-const startTagOpen = new RegExp(`^<${qnameCapture}`)
-const startTagClose = /^\s*(\/?)>/
-const endTag = new RegExp(`^<\\/${qnameCapture}[^>]*>`)
-const doctype = /^<!DOCTYPE [^>]+>/i
-// #7298: escape - to avoid being pased as HTML comment when inlined in page
-const comment = /^<!\--/
-const conditionalComment = /^<!\[/
-
-// Special Elements (can contain anything)
-export const isPlainTextElement = makeMap('script,style,textarea', true)
-const reCache = {}
-
-const decodingMap = {
-  '&lt;': '<',
-  '&gt;': '>',
-  '&quot;': '"',
-  '&amp;': '&',
-  '&#10;': '\n',
-  '&#9;': '\t',
-  '&#39;': "'"
-}
-const encodedAttr = /&(?:lt|gt|quot|amp|#39);/g
-const encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g
-
-// #5992
-const isIgnoreNewlineTag = makeMap('pre,textarea', true)
-const shouldIgnoreFirstNewline = (tag, html) => tag && isIgnoreNewlineTag(tag) && html[0] === '\n'
-
-function decodeAttr (value, shouldDecodeNewlines) {
-  const re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr
-  return value.replace(re, match => decodingMap[match])
-}
-
-export function parseHTML (html, options) {
-  const stack = []
-  const expectHTML = options.expectHTML
-  const isUnaryTag = options.isUnaryTag || no
-  const canBeLeftOpenTag = options.canBeLeftOpenTag || no
-  let index = 0
-  let last, lastTag
-  while (html) {
-    last = html
-    // Make sure we're not in a plaintext content element like script/style
-    if (!lastTag || !isPlainTextElement(lastTag)) {
-      let textEnd = html.indexOf('<')
-      if (textEnd === 0) {
-        // Comment:
-        if (comment.test(html)) {
-          const commentEnd = html.indexOf('-->')
-
-          if (commentEnd >= 0) {
-            if (options.shouldKeepComment) {
-              options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3)
-            }
-            advance(commentEnd + 3)
-            continue
-          }
-        }
-
-        // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
-        if (conditionalComment.test(html)) {
-          const conditionalEnd = html.indexOf(']>')
-
-          if (conditionalEnd >= 0) {
-            advance(conditionalEnd + 2)
-            continue
-          }
-        }
-
-        // Doctype:
-        const doctypeMatch = html.match(doctype)
-        if (doctypeMatch) {
-          advance(doctypeMatch[0].length)
-          continue
-        }
-
-        // End tag:
-        const endTagMatch = html.match(endTag)
-        if (endTagMatch) {
-          const curIndex = index
-          advance(endTagMatch[0].length)
-          parseEndTag(endTagMatch[1], curIndex, index)
-          continue
-        }
-
-        // Start tag:
-        const startTagMatch = parseStartTag()
-        if (startTagMatch) {
-          handleStartTag(startTagMatch)
-          if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
-            advance(1)
-          }
-          continue
-        }
-      }
-
-      let text, rest, next
-      if (textEnd >= 0) {
-        rest = html.slice(textEnd)
-        while (
-          !endTag.test(rest) &&
-          !startTagOpen.test(rest) &&
-          !comment.test(rest) &&
-          !conditionalComment.test(rest)
-        ) {
-          // < in plain text, be forgiving and treat it as text
-          next = rest.indexOf('<', 1)
-          if (next < 0) break
-          textEnd += next
-          rest = html.slice(textEnd)
-        }
-        text = html.substring(0, textEnd)
-      }
-
-      if (textEnd < 0) {
-        text = html
-      }
-
-      if (text) {
-        advance(text.length)
-      }
-
-      if (options.chars && text) {
-        options.chars(text, index - text.length, index)
-      }
-    } else {
-      let endTagLength = 0
-      const stackedTag = lastTag.toLowerCase()
-      const reStackedTag = reCache[stackedTag] || (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'))
-      const rest = html.replace(reStackedTag, function (all, text, endTag) {
-        endTagLength = endTag.length
-        if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
-          text = text
-            .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
-            .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1')
-        }
-        if (shouldIgnoreFirstNewline(stackedTag, text)) {
-          text = text.slice(1)
-        }
-        if (options.chars) {
-          options.chars(text)
-        }
-        return ''
-      })
-      index += html.length - rest.length
-      html = rest
-      parseEndTag(stackedTag, index - endTagLength, index)
-    }
-
-    if (html === last) {
-      options.chars && options.chars(html)
-      if (process.env.NODE_ENV !== 'production' && !stack.length && options.warn) {
-        options.warn(`Mal-formatted tag at end of template: "${html}"`, { start: index + html.length })
-      }
-      break
-    }
-  }
-
-  // Clean up any remaining tags
-  parseEndTag()
-
-  function advance (n) {
-    index += n
-    html = html.substring(n)
-  }
-
-  function parseStartTag () {
-    const start = html.match(startTagOpen)
-    if (start) {
-      const match = {
-        tagName: start[1],
-        attrs: [],
-        start: index
-      }
-      advance(start[0].length)
-      let end, attr
-      while (!(end = html.match(startTagClose)) && (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
-        attr.start = index
-        advance(attr[0].length)
-        attr.end = index
-        match.attrs.push(attr)
-      }
-      if (end) {
-        match.unarySlash = end[1]
-        advance(end[0].length)
-        match.end = index
-        return match
-      }
-    }
-  }
-
-  function handleStartTag (match) {
-    const tagName = match.tagName
-    const unarySlash = match.unarySlash
-
-    if (expectHTML) {
-      if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
-        parseEndTag(lastTag)
-      }
-      if (canBeLeftOpenTag(tagName) && lastTag === tagName) {
-        parseEndTag(tagName)
-      }
-    }
-
-    const unary = isUnaryTag(tagName) || !!unarySlash
-
-    const l = match.attrs.length
-    const attrs = new Array(l)
-    for (let i = 0; i < l; i++) {
-      const args = match.attrs[i]
-      const value = args[3] || args[4] || args[5] || ''
-      const shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
-        ? options.shouldDecodeNewlinesForHref
-        : options.shouldDecodeNewlines
-      attrs[i] = {
-        name: args[1],
-        value: decodeAttr(value, shouldDecodeNewlines)
-      }
-      if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
-        attrs[i].start = args.start + args[0].match(/^\s*/).length
-        attrs[i].end = args.end
-      }
-    }
-
-    if (!unary) {
-      stack.push({ tag: tagName, lowerCasedTag: tagName.toLowerCase(), attrs: attrs, start: match.start, end: match.end })
-      lastTag = tagName
-    }
-
-    if (options.start) {
-      options.start(tagName, attrs, unary, match.start, match.end)
-    }
-  }
-
-  function parseEndTag (tagName, start, end) {
-    let pos, lowerCasedTagName
-    if (start == null) start = index
-    if (end == null) end = index
-
-    // Find the closest opened tag of the same type
-    if (tagName) {
-      lowerCasedTagName = tagName.toLowerCase()
-      for (pos = stack.length - 1; pos >= 0; pos--) {
-        if (stack[pos].lowerCasedTag === lowerCasedTagName) {
-          break
-        }
-      }
-    } else {
-      // If no tag name is provided, clean shop
-      pos = 0
-    }
-
-    if (pos >= 0) {
-      // Close all the open elements, up the stack
-      for (let i = stack.length - 1; i >= pos; i--) {
-        if (process.env.NODE_ENV !== 'production' &&
-          (i > pos || !tagName) &&
-          options.warn
-        ) {
-          options.warn(
-            `tag <${stack[i].tag}> has no matching end tag.`,
-            { start: stack[i].start, end: stack[i].end }
-          )
-        }
-        if (options.end) {
-          options.end(stack[i].tag, start, end)
-        }
-      }
-
-      // Remove the open elements from the stack
-      stack.length = pos
-      lastTag = pos && stack[pos - 1].tag
-    } else if (lowerCasedTagName === 'br') {
-      if (options.start) {
-        options.start(tagName, [], true, start, end)
-      }
-    } else if (lowerCasedTagName === 'p') {
-      if (options.start) {
-        options.start(tagName, [], false, start, end)
-      }
-      if (options.end) {
-        options.end(tagName, start, end)
-      }
-    }
-  }
-}
diff --git a/1.Vue/src/compiler/parser/index.js b/1.Vue/src/compiler/parser/index.js
deleted file mode 100644
index fb25875..0000000
--- a/1.Vue/src/compiler/parser/index.js
+++ /dev/null
@@ -1,975 +0,0 @@
-/* @flow */
-
-import he from 'he'
-import { parseHTML } from './html-parser'
-import { parseText } from './text-parser'
-import { parseFilters } from './filter-parser'
-import { genAssignmentCode } from '../directives/model'
-import { extend, cached, no, camelize, hyphenate } from 'shared/util'
-import { isIE, isEdge, isServerRendering } from 'core/util/env'
-
-import {
-  addProp,
-  addAttr,
-  baseWarn,
-  addHandler,
-  addDirective,
-  getBindingAttr,
-  getAndRemoveAttr,
-  getRawBindingAttr,
-  pluckModuleFunction,
-  getAndRemoveAttrByRegex
-} from '../helpers'
-
-export const onRE = /^@|^v-on:/
-export const dirRE = process.env.VBIND_PROP_SHORTHAND
-  ? /^v-|^@|^:|^\./
-  : /^v-|^@|^:/
-export const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/
-export const forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/
-const stripParensRE = /^\(|\)$/g
-const dynamicArgRE = /^\[.*\]$/
-
-const argRE = /:(.*)$/
-export const bindRE = /^:|^\.|^v-bind:/
-const propBindRE = /^\./
-const modifierRE = /\.[^.\]]+(?=[^\]]*$)/g
-
-const slotRE = /^v-slot(:|$)|^#/
-
-const lineBreakRE = /[\r\n]/
-const whitespaceRE = /\s+/g
-
-const invalidAttributeRE = /[\s"'<>\/=]/
-
-const decodeHTMLCached = cached(he.decode)
-
-export const emptySlotScopeToken = `_empty_`
-
-// configurable state
-export let warn: any
-let delimiters
-let transforms
-let preTransforms
-let postTransforms
-let platformIsPreTag
-let platformMustUseProp
-let platformGetTagNamespace
-let maybeComponent
-
-export function createASTElement (
-  tag: string,
-  attrs: Array<ASTAttr>,
-  parent: ASTElement | void
-): ASTElement {
-  return {
-    type: 1,
-    tag,
-    attrsList: attrs,
-    attrsMap: makeAttrsMap(attrs),
-    rawAttrsMap: {},
-    parent,
-    children: []
-  }
-}
-
-/**
- * Convert HTML string to AST.
- */
-export function parse (
-  template: string,
-  options: CompilerOptions
-): ASTElement | void {
-  warn = options.warn || baseWarn
-
-  platformIsPreTag = options.isPreTag || no
-  platformMustUseProp = options.mustUseProp || no
-  platformGetTagNamespace = options.getTagNamespace || no
-  const isReservedTag = options.isReservedTag || no
-  maybeComponent = (el: ASTElement) => !!el.component || !isReservedTag(el.tag)
-
-  transforms = pluckModuleFunction(options.modules, 'transformNode')
-  preTransforms = pluckModuleFunction(options.modules, 'preTransformNode')
-  postTransforms = pluckModuleFunction(options.modules, 'postTransformNode')
-
-  delimiters = options.delimiters
-
-  const stack = []
-  const preserveWhitespace = options.preserveWhitespace !== false
-  const whitespaceOption = options.whitespace
-  let root
-  let currentParent
-  let inVPre = false
-  let inPre = false
-  let warned = false
-
-  function warnOnce (msg, range) {
-    if (!warned) {
-      warned = true
-      warn(msg, range)
-    }
-  }
-
-  function closeElement (element) {
-    trimEndingWhitespace(element)
-    if (!inVPre && !element.processed) {
-      element = processElement(element, options)
-    }
-    // tree management
-    if (!stack.length && element !== root) {
-      // allow root elements with v-if, v-else-if and v-else
-      if (root.if && (element.elseif || element.else)) {
-        if (process.env.NODE_ENV !== 'production') {
-          checkRootConstraints(element)
-        }
-        addIfCondition(root, {
-          exp: element.elseif,
-          block: element
-        })
-      } else if (process.env.NODE_ENV !== 'production') {
-        warnOnce(
-          `Component template should contain exactly one root element. ` +
-          `If you are using v-if on multiple elements, ` +
-          `use v-else-if to chain them instead.`,
-          { start: element.start }
-        )
-      }
-    }
-    if (currentParent && !element.forbidden) {
-      if (element.elseif || element.else) {
-        processIfConditions(element, currentParent)
-      } else {
-        if (element.slotScope) {
-          // scoped slot
-          // keep it in the children list so that v-else(-if) conditions can
-          // find it as the prev node.
-          const name = element.slotTarget || '"default"'
-          ;(currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element
-        }
-        currentParent.children.push(element)
-        element.parent = currentParent
-      }
-    }
-
-    // final children cleanup
-    // filter out scoped slots
-    element.children = element.children.filter(c => !(c: any).slotScope)
-    // remove trailing whitespace node again
-    trimEndingWhitespace(element)
-
-    // check pre state
-    if (element.pre) {
-      inVPre = false
-    }
-    if (platformIsPreTag(element.tag)) {
-      inPre = false
-    }
-    // apply post-transforms
-    for (let i = 0; i < postTransforms.length; i++) {
-      postTransforms[i](element, options)
-    }
-  }
-
-  function trimEndingWhitespace (el) {
-    // remove trailing whitespace node
-    if (!inPre) {
-      let lastNode
-      while (
-        (lastNode = el.children[el.children.length - 1]) &&
-        lastNode.type === 3 &&
-        lastNode.text === ' '
-      ) {
-        el.children.pop()
-      }
-    }
-  }
-
-  function checkRootConstraints (el) {
-    if (el.tag === 'slot' || el.tag === 'template') {
-      warnOnce(
-        `Cannot use <${el.tag}> as component root element because it may ` +
-        'contain multiple nodes.',
-        { start: el.start }
-      )
-    }
-    if (el.attrsMap.hasOwnProperty('v-for')) {
-      warnOnce(
-        'Cannot use v-for on stateful component root element because ' +
-        'it renders multiple elements.',
-        el.rawAttrsMap['v-for']
-      )
-    }
-  }
-
-  parseHTML(template, {
-    warn,
-    expectHTML: options.expectHTML,
-    isUnaryTag: options.isUnaryTag,
-    canBeLeftOpenTag: options.canBeLeftOpenTag,
-    shouldDecodeNewlines: options.shouldDecodeNewlines,
-    shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
-    shouldKeepComment: options.comments,
-    outputSourceRange: options.outputSourceRange,
-    start (tag, attrs, unary, start, end) {
-      // check namespace.
-      // inherit parent ns if there is one
-      const ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag)
-
-      // handle IE svg bug
-      /* istanbul ignore if */
-      if (isIE && ns === 'svg') {
-        attrs = guardIESVGBug(attrs)
-      }
-
-      let element: ASTElement = createASTElement(tag, attrs, currentParent)
-      if (ns) {
-        element.ns = ns
-      }
-
-      if (process.env.NODE_ENV !== 'production') {
-        if (options.outputSourceRange) {
-          element.start = start
-          element.end = end
-          element.rawAttrsMap = element.attrsList.reduce((cumulated, attr) => {
-            cumulated[attr.name] = attr
-            return cumulated
-          }, {})
-        }
-        attrs.forEach(attr => {
-          if (invalidAttributeRE.test(attr.name)) {
-            warn(
-              `Invalid dynamic argument expression: attribute names cannot contain ` +
-              `spaces, quotes, <, >, / or =.`,
-              {
-                start: attr.start + attr.name.indexOf(`[`),
-                end: attr.start + attr.name.length
-              }
-            )
-          }
-        })
-      }
-
-      if (isForbiddenTag(element) && !isServerRendering()) {
-        element.forbidden = true
-        process.env.NODE_ENV !== 'production' && warn(
-          'Templates should only be responsible for mapping the state to the ' +
-          'UI. Avoid placing tags with side-effects in your templates, such as ' +
-          `<${tag}>` + ', as they will not be parsed.',
-          { start: element.start }
-        )
-      }
-
-      // apply pre-transforms
-      for (let i = 0; i < preTransforms.length; i++) {
-        element = preTransforms[i](element, options) || element
-      }
-
-      if (!inVPre) {
-        processPre(element)
-        if (element.pre) {
-          inVPre = true
-        }
-      }
-      if (platformIsPreTag(element.tag)) {
-        inPre = true
-      }
-      if (inVPre) {
-        processRawAttrs(element)
-      } else if (!element.processed) {
-        // structural directives
-        processFor(element)
-        processIf(element)
-        processOnce(element)
-      }
-
-      if (!root) {
-        root = element
-        if (process.env.NODE_ENV !== 'production') {
-          checkRootConstraints(root)
-        }
-      }
-
-      if (!unary) {
-        currentParent = element
-        stack.push(element)
-      } else {
-        closeElement(element)
-      }
-    },
-
-    end (tag, start, end) {
-      const element = stack[stack.length - 1]
-      // pop stack
-      stack.length -= 1
-      currentParent = stack[stack.length - 1]
-      if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
-        element.end = end
-      }
-      closeElement(element)
-    },
-
-    chars (text: string, start: number, end: number) {
-      if (!currentParent) {
-        if (process.env.NODE_ENV !== 'production') {
-          if (text === template) {
-            warnOnce(
-              'Component template requires a root element, rather than just text.',
-              { start }
-            )
-          } else if ((text = text.trim())) {
-            warnOnce(
-              `text "${text}" outside root element will be ignored.`,
-              { start }
-            )
-          }
-        }
-        return
-      }
-      // IE textarea placeholder bug
-      /* istanbul ignore if */
-      if (isIE &&
-        currentParent.tag === 'textarea' &&
-        currentParent.attrsMap.placeholder === text
-      ) {
-        return
-      }
-      const children = currentParent.children
-      if (inPre || text.trim()) {
-        text = isTextTag(currentParent) ? text : decodeHTMLCached(text)
-      } else if (!children.length) {
-        // remove the whitespace-only node right after an opening tag
-        text = ''
-      } else if (whitespaceOption) {
-        if (whitespaceOption === 'condense') {
-          // in condense mode, remove the whitespace node if it contains
-          // line break, otherwise condense to a single space
-          text = lineBreakRE.test(text) ? '' : ' '
-        } else {
-          text = ' '
-        }
-      } else {
-        text = preserveWhitespace ? ' ' : ''
-      }
-      if (text) {
-        if (!inPre && whitespaceOption === 'condense') {
-          // condense consecutive whitespaces into single space
-          text = text.replace(whitespaceRE, ' ')
-        }
-        let res
-        let child: ?ASTNode
-        if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
-          child = {
-            type: 2,
-            expression: res.expression,
-            tokens: res.tokens,
-            text
-          }
-        } else if (text !== ' ' || !children.length || children[children.length - 1].text !== ' ') {
-          child = {
-            type: 3,
-            text
-          }
-        }
-        if (child) {
-          if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
-            child.start = start
-            child.end = end
-          }
-          children.push(child)
-        }
-      }
-    },
-    comment (text: string, start, end) {
-      // adding anyting as a sibling to the root node is forbidden
-      // comments should still be allowed, but ignored
-      if (currentParent) {
-        const child: ASTText = {
-          type: 3,
-          text,
-          isComment: true
-        }
-        if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
-          child.start = start
-          child.end = end
-        }
-        currentParent.children.push(child)
-      }
-    }
-  })
-  return root
-}
-
-function processPre (el) {
-  if (getAndRemoveAttr(el, 'v-pre') != null) {
-    el.pre = true
-  }
-}
-
-function processRawAttrs (el) {
-  const list = el.attrsList
-  const len = list.length
-  if (len) {
-    const attrs: Array<ASTAttr> = el.attrs = new Array(len)
-    for (let i = 0; i < len; i++) {
-      attrs[i] = {
-        name: list[i].name,
-        value: JSON.stringify(list[i].value)
-      }
-      if (list[i].start != null) {
-        attrs[i].start = list[i].start
-        attrs[i].end = list[i].end
-      }
-    }
-  } else if (!el.pre) {
-    // non root node in pre blocks with no attributes
-    el.plain = true
-  }
-}
-
-export function processElement (
-  element: ASTElement,
-  options: CompilerOptions
-) {
-  processKey(element)
-
-  // determine whether this is a plain element after
-  // removing structural attributes
-  element.plain = (
-    !element.key &&
-    !element.scopedSlots &&
-    !element.attrsList.length
-  )
-
-  processRef(element)
-  processSlotContent(element)
-  processSlotOutlet(element)
-  processComponent(element)
-  for (let i = 0; i < transforms.length; i++) {
-    element = transforms[i](element, options) || element
-  }
-  processAttrs(element)
-  return element
-}
-
-function processKey (el) {
-  const exp = getBindingAttr(el, 'key')
-  if (exp) {
-    if (process.env.NODE_ENV !== 'production') {
-      if (el.tag === 'template') {
-        warn(
-          `<template> cannot be keyed. Place the key on real elements instead.`,
-          getRawBindingAttr(el, 'key')
-        )
-      }
-      if (el.for) {
-        const iterator = el.iterator2 || el.iterator1
-        const parent = el.parent
-        if (iterator && iterator === exp && parent && parent.tag === 'transition-group') {
-          warn(
-            `Do not use v-for index as key on <transition-group> children, ` +
-            `this is the same as not using keys.`,
-            getRawBindingAttr(el, 'key'),
-            true /* tip */
-          )
-        }
-      }
-    }
-    el.key = exp
-  }
-}
-
-function processRef (el) {
-  const ref = getBindingAttr(el, 'ref')
-  if (ref) {
-    el.ref = ref
-    el.refInFor = checkInFor(el)
-  }
-}
-
-export function processFor (el: ASTElement) {
-  let exp
-  if ((exp = getAndRemoveAttr(el, 'v-for'))) {
-    const res = parseFor(exp)
-    if (res) {
-      extend(el, res)
-    } else if (process.env.NODE_ENV !== 'production') {
-      warn(
-        `Invalid v-for expression: ${exp}`,
-        el.rawAttrsMap['v-for']
-      )
-    }
-  }
-}
-
-type ForParseResult = {
-  for: string;
-  alias: string;
-  iterator1?: string;
-  iterator2?: string;
-};
-
-export function parseFor (exp: string): ?ForParseResult {
-  const inMatch = exp.match(forAliasRE)
-  if (!inMatch) return
-  const res = {}
-  res.for = inMatch[2].trim()
-  const alias = inMatch[1].trim().replace(stripParensRE, '')
-  const iteratorMatch = alias.match(forIteratorRE)
-  if (iteratorMatch) {
-    res.alias = alias.replace(forIteratorRE, '').trim()
-    res.iterator1 = iteratorMatch[1].trim()
-    if (iteratorMatch[2]) {
-      res.iterator2 = iteratorMatch[2].trim()
-    }
-  } else {
-    res.alias = alias
-  }
-  return res
-}
-
-function processIf (el) {
-  const exp = getAndRemoveAttr(el, 'v-if')
-  if (exp) {
-    el.if = exp
-    addIfCondition(el, {
-      exp: exp,
-      block: el
-    })
-  } else {
-    if (getAndRemoveAttr(el, 'v-else') != null) {
-      el.else = true
-    }
-    const elseif = getAndRemoveAttr(el, 'v-else-if')
-    if (elseif) {
-      el.elseif = elseif
-    }
-  }
-}
-
-function processIfConditions (el, parent) {
-  const prev = findPrevElement(parent.children)
-  if (prev && prev.if) {
-    addIfCondition(prev, {
-      exp: el.elseif,
-      block: el
-    })
-  } else if (process.env.NODE_ENV !== 'production') {
-    warn(
-      `v-${el.elseif ? ('else-if="' + el.elseif + '"') : 'else'} ` +
-      `used on element <${el.tag}> without corresponding v-if.`,
-      el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']
-    )
-  }
-}
-
-function findPrevElement (children: Array<any>): ASTElement | void {
-  let i = children.length
-  while (i--) {
-    if (children[i].type === 1) {
-      return children[i]
-    } else {
-      if (process.env.NODE_ENV !== 'production' && children[i].text !== ' ') {
-        warn(
-          `text "${children[i].text.trim()}" between v-if and v-else(-if) ` +
-          `will be ignored.`,
-          children[i]
-        )
-      }
-      children.pop()
-    }
-  }
-}
-
-export function addIfCondition (el: ASTElement, condition: ASTIfCondition) {
-  if (!el.ifConditions) {
-    el.ifConditions = []
-  }
-  el.ifConditions.push(condition)
-}
-
-function processOnce (el) {
-  const once = getAndRemoveAttr(el, 'v-once')
-  if (once != null) {
-    el.once = true
-  }
-}
-
-// handle content being passed to a component as slot,
-// e.g. <template slot="xxx">, <div slot-scope="xxx">
-function processSlotContent (el) {
-  let slotScope
-  if (el.tag === 'template') {
-    slotScope = getAndRemoveAttr(el, 'scope')
-    /* istanbul ignore if */
-    if (process.env.NODE_ENV !== 'production' && slotScope) {
-      warn(
-        `the "scope" attribute for scoped slots have been deprecated and ` +
-        `replaced by "slot-scope" since 2.5. The new "slot-scope" attribute ` +
-        `can also be used on plain elements in addition to <template> to ` +
-        `denote scoped slots.`,
-        el.rawAttrsMap['scope'],
-        true
-      )
-    }
-    el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope')
-  } else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
-    /* istanbul ignore if */
-    if (process.env.NODE_ENV !== 'production' && el.attrsMap['v-for']) {
-      warn(
-        `Ambiguous combined usage of slot-scope and v-for on <${el.tag}> ` +
-        `(v-for takes higher priority). Use a wrapper <template> for the ` +
-        `scoped slot to make it clearer.`,
-        el.rawAttrsMap['slot-scope'],
-        true
-      )
-    }
-    el.slotScope = slotScope
-  }
-
-  // slot="xxx"
-  const slotTarget = getBindingAttr(el, 'slot')
-  if (slotTarget) {
-    el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget
-    el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot'])
-    // preserve slot as an attribute for native shadow DOM compat
-    // only for non-scoped slots.
-    if (el.tag !== 'template' && !el.slotScope) {
-      addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'))
-    }
-  }
-
-  // 2.6 v-slot syntax
-  if (process.env.NEW_SLOT_SYNTAX) {
-    if (el.tag === 'template') {
-      // v-slot on <template>
-      const slotBinding = getAndRemoveAttrByRegex(el, slotRE)
-      if (slotBinding) {
-        if (process.env.NODE_ENV !== 'production') {
-          if (el.slotTarget || el.slotScope) {
-            warn(
-              `Unexpected mixed usage of different slot syntaxes.`,
-              el
-            )
-          }
-          if (el.parent && !maybeComponent(el.parent)) {
-            warn(
-              `<template v-slot> can only appear at the root level inside ` +
-              `the receiving the component`,
-              el
-            )
-          }
-        }
-        const { name, dynamic } = getSlotName(slotBinding)
-        el.slotTarget = name
-        el.slotTargetDynamic = dynamic
-        el.slotScope = slotBinding.value || emptySlotScopeToken // force it into a scoped slot for perf
-      }
-    } else {
-      // v-slot on component, denotes default slot
-      const slotBinding = getAndRemoveAttrByRegex(el, slotRE)
-      if (slotBinding) {
-        if (process.env.NODE_ENV !== 'production') {
-          if (!maybeComponent(el)) {
-            warn(
-              `v-slot can only be used on components or <template>.`,
-              slotBinding
-            )
-          }
-          if (el.slotScope || el.slotTarget) {
-            warn(
-              `Unexpected mixed usage of different slot syntaxes.`,
-              el
-            )
-          }
-          if (el.scopedSlots) {
-            warn(
-              `To avoid scope ambiguity, the default slot should also use ` +
-              `<template> syntax when there are other named slots.`,
-              slotBinding
-            )
-          }
-        }
-        // add the component's children to its default slot
-        const slots = el.scopedSlots || (el.scopedSlots = {})
-        const { name, dynamic } = getSlotName(slotBinding)
-        const slotContainer = slots[name] = createASTElement('template', [], el)
-        slotContainer.slotTarget = name
-        slotContainer.slotTargetDynamic = dynamic
-        slotContainer.children = el.children.filter((c: any) => {
-          if (!c.slotScope) {
-            c.parent = slotContainer
-            return true
-          }
-        })
-        slotContainer.slotScope = slotBinding.value || emptySlotScopeToken
-        // remove children as they are returned from scopedSlots now
-        el.children = []
-        // mark el non-plain so data gets generated
-        el.plain = false
-      }
-    }
-  }
-}
-
-function getSlotName (binding) {
-  let name = binding.name.replace(slotRE, '')
-  if (!name) {
-    if (binding.name[0] !== '#') {
-      name = 'default'
-    } else if (process.env.NODE_ENV !== 'production') {
-      warn(
-        `v-slot shorthand syntax requires a slot name.`,
-        binding
-      )
-    }
-  }
-  return dynamicArgRE.test(name)
-    // dynamic [name]
-    ? { name: name.slice(1, -1), dynamic: true }
-    // static name
-    : { name: `"${name}"`, dynamic: false }
-}
-
-// handle <slot/> outlets
-function processSlotOutlet (el) {
-  if (el.tag === 'slot') {
-    el.slotName = getBindingAttr(el, 'name')
-    if (process.env.NODE_ENV !== 'production' && el.key) {
-      warn(
-        `\`key\` does not work on <slot> because slots are abstract outlets ` +
-        `and can possibly expand into multiple elements. ` +
-        `Use the key on a wrapping element instead.`,
-        getRawBindingAttr(el, 'key')
-      )
-    }
-  }
-}
-
-function processComponent (el) {
-  let binding
-  if ((binding = getBindingAttr(el, 'is'))) {
-    el.component = binding
-  }
-  if (getAndRemoveAttr(el, 'inline-template') != null) {
-    el.inlineTemplate = true
-  }
-}
-
-function processAttrs (el) {
-  const list = el.attrsList
-  let i, l, name, rawName, value, modifiers, syncGen, isDynamic
-  for (i = 0, l = list.length; i < l; i++) {
-    name = rawName = list[i].name
-    value = list[i].value
-    if (dirRE.test(name)) {
-      // mark element as dynamic
-      el.hasBindings = true
-      // modifiers
-      modifiers = parseModifiers(name.replace(dirRE, ''))
-      // support .foo shorthand syntax for the .prop modifier
-      if (process.env.VBIND_PROP_SHORTHAND && propBindRE.test(name)) {
-        (modifiers || (modifiers = {})).prop = true
-        name = `.` + name.slice(1).replace(modifierRE, '')
-      } else if (modifiers) {
-        name = name.replace(modifierRE, '')
-      }
-      if (bindRE.test(name)) { // v-bind
-        name = name.replace(bindRE, '')
-        value = parseFilters(value)
-        isDynamic = dynamicArgRE.test(name)
-        if (isDynamic) {
-          name = name.slice(1, -1)
-        }
-        if (
-          process.env.NODE_ENV !== 'production' &&
-          value.trim().length === 0
-        ) {
-          warn(
-            `The value for a v-bind expression cannot be empty. Found in "v-bind:${name}"`
-          )
-        }
-        if (modifiers) {
-          if (modifiers.prop && !isDynamic) {
-            name = camelize(name)
-            if (name === 'innerHtml') name = 'innerHTML'
-          }
-          if (modifiers.camel && !isDynamic) {
-            name = camelize(name)
-          }
-          if (modifiers.sync) {
-            syncGen = genAssignmentCode(value, `$event`)
-            if (!isDynamic) {
-              addHandler(
-                el,
-                `update:${camelize(name)}`,
-                syncGen,
-                null,
-                false,
-                warn,
-                list[i]
-              )
-              if (hyphenate(name) !== camelize(name)) {
-                addHandler(
-                  el,
-                  `update:${hyphenate(name)}`,
-                  syncGen,
-                  null,
-                  false,
-                  warn,
-                  list[i]
-                )
-              }
-            } else {
-              // handler w/ dynamic event name
-              addHandler(
-                el,
-                `"update:"+(${name})`,
-                syncGen,
-                null,
-                false,
-                warn,
-                list[i],
-                true // dynamic
-              )
-            }
-          }
-        }
-        if ((modifiers && modifiers.prop) || (
-          !el.component && platformMustUseProp(el.tag, el.attrsMap.type, name)
-        )) {
-          addProp(el, name, value, list[i], isDynamic)
-        } else {
-          addAttr(el, name, value, list[i], isDynamic)
-        }
-      } else if (onRE.test(name)) { // v-on
-        name = name.replace(onRE, '')
-        isDynamic = dynamicArgRE.test(name)
-        if (isDynamic) {
-          name = name.slice(1, -1)
-        }
-        addHandler(el, name, value, modifiers, false, warn, list[i], isDynamic)
-      } else { // normal directives
-        name = name.replace(dirRE, '')
-        // parse arg
-        const argMatch = name.match(argRE)
-        let arg = argMatch && argMatch[1]
-        isDynamic = false
-        if (arg) {
-          name = name.slice(0, -(arg.length + 1))
-          if (dynamicArgRE.test(arg)) {
-            arg = arg.slice(1, -1)
-            isDynamic = true
-          }
-        }
-        addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i])
-        if (process.env.NODE_ENV !== 'production' && name === 'model') {
-          checkForAliasModel(el, value)
-        }
-      }
-    } else {
-      // literal attribute
-      if (process.env.NODE_ENV !== 'production') {
-        const res = parseText(value, delimiters)
-        if (res) {
-          warn(
-            `${name}="${value}": ` +
-            'Interpolation inside attributes has been removed. ' +
-            'Use v-bind or the colon shorthand instead. For example, ' +
-            'instead of <div id="{{ val }}">, use <div :id="val">.',
-            list[i]
-          )
-        }
-      }
-      addAttr(el, name, JSON.stringify(value), list[i])
-      // #6887 firefox doesn't update muted state if set via attribute
-      // even immediately after element creation
-      if (!el.component &&
-          name === 'muted' &&
-          platformMustUseProp(el.tag, el.attrsMap.type, name)) {
-        addProp(el, name, 'true', list[i])
-      }
-    }
-  }
-}
-
-function checkInFor (el: ASTElement): boolean {
-  let parent = el
-  while (parent) {
-    if (parent.for !== undefined) {
-      return true
-    }
-    parent = parent.parent
-  }
-  return false
-}
-
-function parseModifiers (name: string): Object | void {
-  const match = name.match(modifierRE)
-  if (match) {
-    const ret = {}
-    match.forEach(m => { ret[m.slice(1)] = true })
-    return ret
-  }
-}
-
-function makeAttrsMap (attrs: Array<Object>): Object {
-  const map = {}
-  for (let i = 0, l = attrs.length; i < l; i++) {
-    if (
-      process.env.NODE_ENV !== 'production' &&
-      map[attrs[i].name] && !isIE && !isEdge
-    ) {
-      warn('duplicate attribute: ' + attrs[i].name, attrs[i])
-    }
-    map[attrs[i].name] = attrs[i].value
-  }
-  return map
-}
-
-// for script (e.g. type="x/template") or style, do not decode content
-function isTextTag (el): boolean {
-  return el.tag === 'script' || el.tag === 'style'
-}
-
-function isForbiddenTag (el): boolean {
-  return (
-    el.tag === 'style' ||
-    (el.tag === 'script' && (
-      !el.attrsMap.type ||
-      el.attrsMap.type === 'text/javascript'
-    ))
-  )
-}
-
-const ieNSBug = /^xmlns:NS\d+/
-const ieNSPrefix = /^NS\d+:/
-
-/* istanbul ignore next */
-function guardIESVGBug (attrs) {
-  const res = []
-  for (let i = 0; i < attrs.length; i++) {
-    const attr = attrs[i]
-    if (!ieNSBug.test(attr.name)) {
-      attr.name = attr.name.replace(ieNSPrefix, '')
-      res.push(attr)
-    }
-  }
-  return res
-}
-
-function checkForAliasModel (el, value) {
-  let _el = el
-  while (_el) {
-    if (_el.for && _el.alias === value) {
-      warn(
-        `<${el.tag} v-model="${value}">: ` +
-        `You are binding v-model directly to a v-for iteration alias. ` +
-        `This will not be able to modify the v-for source array because ` +
-        `writing to the alias is like modifying a function local variable. ` +
-        `Consider using an array of objects and use v-model on an object property instead.`,
-        el.rawAttrsMap['v-model']
-      )
-    }
-    _el = _el.parent
-  }
-}
diff --git a/1.Vue/src/compiler/parser/text-parser.js b/1.Vue/src/compiler/parser/text-parser.js
deleted file mode 100644
index cf82a62..0000000
--- a/1.Vue/src/compiler/parser/text-parser.js
+++ /dev/null
@@ -1,53 +0,0 @@
-/* @flow */
-
-import { cached } from 'shared/util'
-import { parseFilters } from './filter-parser'
-
-const defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g
-const regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g
-
-const buildRegex = cached(delimiters => {
-  const open = delimiters[0].replace(regexEscapeRE, '\\$&')
-  const close = delimiters[1].replace(regexEscapeRE, '\\$&')
-  return new RegExp(open + '((?:.|\\n)+?)' + close, 'g')
-})
-
-type TextParseResult = {
-  expression: string,
-  tokens: Array<string | { '@binding': string }>
-}
-
-export function parseText (
-  text: string,
-  delimiters?: [string, string]
-): TextParseResult | void {
-  const tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE
-  if (!tagRE.test(text)) {
-    return
-  }
-  const tokens = []
-  const rawTokens = []
-  let lastIndex = tagRE.lastIndex = 0
-  let match, index, tokenValue
-  while ((match = tagRE.exec(text))) {
-    index = match.index
-    // push text token
-    if (index > lastIndex) {
-      rawTokens.push(tokenValue = text.slice(lastIndex, index))
-      tokens.push(JSON.stringify(tokenValue))
-    }
-    // tag token
-    const exp = parseFilters(match[1].trim())
-    tokens.push(`_s(${exp})`)
-    rawTokens.push({ '@binding': exp })
-    lastIndex = index + match[0].length
-  }
-  if (lastIndex < text.length) {
-    rawTokens.push(tokenValue = text.slice(lastIndex))
-    tokens.push(JSON.stringify(tokenValue))
-  }
-  return {
-    expression: tokens.join('+'),
-    tokens: rawTokens
-  }
-}
diff --git a/1.Vue/src/compiler/to-function.js b/1.Vue/src/compiler/to-function.js
deleted file mode 100644
index f607ec3..0000000
--- a/1.Vue/src/compiler/to-function.js
+++ /dev/null
@@ -1,114 +0,0 @@
-/* @flow */
-
-import { noop, extend } from 'shared/util'
-import { warn as baseWarn, tip } from 'core/util/debug'
-import { generateCodeFrame } from './codeframe'
-
-type CompiledFunctionResult = {
-  render: Function;
-  staticRenderFns: Array<Function>;
-};
-
-function createFunction (code, errors) {
-  try {
-    return new Function(code)
-  } catch (err) {
-    errors.push({ err, code })
-    return noop
-  }
-}
-
-export function createCompileToFunctionFn (compile: Function): Function {
-  const cache = Object.create(null)
-
-  return function compileToFunctions (
-    template: string,
-    options?: CompilerOptions,
-    vm?: Component
-  ): CompiledFunctionResult {
-    options = extend({}, options)
-    const warn = options.warn || baseWarn
-    delete options.warn
-
-    /* istanbul ignore if */
-    if (process.env.NODE_ENV !== 'production') {
-      // detect possible CSP restriction
-      try {
-        new Function('return 1')
-      } catch (e) {
-        if (e.toString().match(/unsafe-eval|CSP/)) {
-          warn(
-            'It seems you are using the standalone build of Vue.js in an ' +
-            'environment with Content Security Policy that prohibits unsafe-eval. ' +
-            'The template compiler cannot work in this environment. Consider ' +
-            'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
-            'templates into render functions.'
-          )
-        }
-      }
-    }
-
-    // check cache
-    const key = options.delimiters
-      ? String(options.delimiters) + template
-      : template
-    if (cache[key]) {
-      return cache[key]
-    }
-
-    // compile
-    const compiled = compile(template, options)
-
-    // check compilation errors/tips
-    if (process.env.NODE_ENV !== 'production') {
-      if (compiled.errors && compiled.errors.length) {
-        if (options.outputSourceRange) {
-          compiled.errors.forEach(e => {
-            warn(
-              `Error compiling template:\n\n${e.msg}\n\n` +
-              generateCodeFrame(template, e.start, e.end),
-              vm
-            )
-          })
-        } else {
-          warn(
-            `Error compiling template:\n\n${template}\n\n` +
-            compiled.errors.map(e => `- ${e}`).join('\n') + '\n',
-            vm
-          )
-        }
-      }
-      if (compiled.tips && compiled.tips.length) {
-        if (options.outputSourceRange) {
-          compiled.tips.forEach(e => tip(e.msg, vm))
-        } else {
-          compiled.tips.forEach(msg => tip(msg, vm))
-        }
-      }
-    }
-
-    // turn code into functions
-    const res = {}
-    const fnGenErrors = []
-    res.render = createFunction(compiled.render, fnGenErrors)
-    res.staticRenderFns = compiled.staticRenderFns.map(code => {
-      return createFunction(code, fnGenErrors)
-    })
-
-    // check function generation errors.
-    // this should only happen if there is a bug in the compiler itself.
-    // mostly for codegen development use
-    /* istanbul ignore if */
-    if (process.env.NODE_ENV !== 'production') {
-      if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
-        warn(
-          `Failed to generate render function:\n\n` +
-          fnGenErrors.map(({ err, code }) => `${err.toString()} in\n\n${code}\n`).join('\n'),
-          vm
-        )
-      }
-    }
-
-    return (cache[key] = res)
-  }
-}
diff --git a/1.Vue/src/core/components/index.js b/1.Vue/src/core/components/index.js
deleted file mode 100644
index 5461c76..0000000
--- a/1.Vue/src/core/components/index.js
+++ /dev/null
@@ -1,5 +0,0 @@
-import KeepAlive from './keep-alive'
-
-export default {
-  KeepAlive
-}
diff --git a/1.Vue/src/core/components/keep-alive.js b/1.Vue/src/core/components/keep-alive.js
deleted file mode 100644
index fb4cf1e..0000000
--- a/1.Vue/src/core/components/keep-alive.js
+++ /dev/null
@@ -1,124 +0,0 @@
-/* @flow */
-
-import { isRegExp, remove } from 'shared/util'
-import { getFirstComponentChild } from 'core/vdom/helpers/index'
-
-type VNodeCache = { [key: string]: ?VNode };
-
-function getComponentName (opts: ?VNodeComponentOptions): ?string {
-  return opts && (opts.Ctor.options.name || opts.tag)
-}
-
-function matches (pattern: string | RegExp | Array<string>, name: string): boolean {
-  if (Array.isArray(pattern)) {
-    return pattern.indexOf(name) > -1
-  } else if (typeof pattern === 'string') {
-    return pattern.split(',').indexOf(name) > -1
-  } else if (isRegExp(pattern)) {
-    return pattern.test(name)
-  }
-  /* istanbul ignore next */
-  return false
-}
-
-function pruneCache (keepAliveInstance: any, filter: Function) {
-  const { cache, keys, _vnode } = keepAliveInstance
-  for (const key in cache) {
-    const cachedNode: ?VNode = cache[key]
-    if (cachedNode) {
-      const name: ?string = getComponentName(cachedNode.componentOptions)
-      if (name && !filter(name)) {
-        pruneCacheEntry(cache, key, keys, _vnode)
-      }
-    }
-  }
-}
-
-function pruneCacheEntry (
-  cache: VNodeCache,
-  key: string,
-  keys: Array<string>,
-  current?: VNode
-) {
-  const cached = cache[key]
-  if (cached && (!current || cached.tag !== current.tag)) {
-    cached.componentInstance.$destroy()
-  }
-  cache[key] = null
-  remove(keys, key)
-}
-
-const patternTypes: Array<Function> = [String, RegExp, Array]
-
-export default {
-  name: 'keep-alive',
-  abstract: true,
-
-  props: {
-    include: patternTypes,
-    exclude: patternTypes,
-    max: [String, Number]
-  },
-
-  created () {
-    this.cache = Object.create(null)
-    this.keys = []
-  },
-
-  destroyed () {
-    for (const key in this.cache) {
-      pruneCacheEntry(this.cache, key, this.keys)
-    }
-  },
-
-  mounted () {
-    this.$watch('include', val => {
-      pruneCache(this, name => matches(val, name))
-    })
-    this.$watch('exclude', val => {
-      pruneCache(this, name => !matches(val, name))
-    })
-  },
-
-  render () {
-    const slot = this.$slots.default
-    const vnode: VNode = getFirstComponentChild(slot)
-    const componentOptions: ?VNodeComponentOptions = vnode && vnode.componentOptions
-    if (componentOptions) {
-      // check pattern
-      const name: ?string = getComponentName(componentOptions)
-      const { include, exclude } = this
-      if (
-        // not included
-        (include && (!name || !matches(include, name))) ||
-        // excluded
-        (exclude && name && matches(exclude, name))
-      ) {
-        return vnode
-      }
-
-      const { cache, keys } = this
-      const key: ?string = vnode.key == null
-        // same constructor may get registered as different local components
-        // so cid alone is not enough (#3269)
-        ? componentOptions.Ctor.cid + (componentOptions.tag ? `::${componentOptions.tag}` : '')
-        : vnode.key
-      if (cache[key]) {
-        vnode.componentInstance = cache[key].componentInstance
-        // make current key freshest
-        remove(keys, key)
-        keys.push(key)
-      } else {
-        cache[key] = vnode
-        keys.push(key)
-        // prune oldest entry
-        if (this.max && keys.length > parseInt(this.max)) {
-          pruneCacheEntry(cache, keys[0], keys, this._vnode)
-        }
-      }
-
-      vnode.data.keepAlive = true
-    }
-    return vnode || (slot && slot[0])
-  }
-}
diff --git a/1.Vue/src/core/config.js b/1.Vue/src/core/config.js
deleted file mode 100644
index cae9d3d..0000000
--- a/1.Vue/src/core/config.js
+++ /dev/null
@@ -1,130 +0,0 @@
-/* @flow */
-
-import {
-  no,
-  noop,
-  identity
-} from 'shared/util'
-
-import { LIFECYCLE_HOOKS } from 'shared/constants'
-
-export type Config = {
-  // user
-  optionMergeStrategies: { [key: string]: Function };
-  silent: boolean;
-  productionTip: boolean;
-  performance: boolean;
-  devtools: boolean;
-  errorHandler: ?(err: Error, vm: Component, info: string) => void;
-  warnHandler: ?(msg: string, vm: Component, trace: string) => void;
-  ignoredElements: Array<string | RegExp>;
-  keyCodes: { [key: string]: number | Array<number> };
-
-  // platform
-  isReservedTag: (x?: string) => boolean;
-  isReservedAttr: (x?: string) => boolean;
-  parsePlatformTagName: (x: string) => string;
-  isUnknownElement: (x?: string) => boolean;
-  getTagNamespace: (x?: string) => string | void;
-  mustUseProp: (tag: string, type: ?string, name: string) => boolean;
-
-  // private
-  async: boolean;
-
-  // legacy
-  _lifecycleHooks: Array<string>;
-};
-
-export default ({
-  /**
-   * Option merge strategies (used in core/util/options)
-   */
-  // $flow-disable-line
-  optionMergeStrategies: Object.create(null),
-
-  /**
-   * Whether to suppress warnings.
-   */
-  silent: false,
-
-  /**
-   * Show production mode tip message on boot?
-   */
-  productionTip: process.env.NODE_ENV !== 'production',
-
-  /**
-   * Whether to enable devtools
-   */
-  devtools: process.env.NODE_ENV !== '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
-   */
-  // $flow-disable-line
-  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,
-
-  /**
-   * Perform updates asynchronously. Intended to be used by Vue Test Utils
-   * This will significantly reduce performance if set to false.
-   */
-  async: true,
-
-  /**
-   * Exposed for legacy reasons
-   */
-  _lifecycleHooks: LIFECYCLE_HOOKS
-}: Config)
diff --git a/1.Vue/src/core/global-api/assets.js b/1.Vue/src/core/global-api/assets.js
deleted file mode 100644
index d975a6a..0000000
--- a/1.Vue/src/core/global-api/assets.js
+++ /dev/null
@@ -1,34 +0,0 @@
-/* @flow */
-
-import { ASSET_TYPES } from 'shared/constants'
-import { isPlainObject, validateComponentName } from '../util/index'
-
-export function initAssetRegisters (Vue: GlobalAPI) {
-  /**
-   * Create asset registration methods.
-   */
-  ASSET_TYPES.forEach(type => {
-    Vue[type] = function (
-      id: string,
-      definition: Function | Object
-    ): Function | Object | void {
-      if (!definition) {
-        return this.options[type + 's'][id]
-      } else {
-        /* istanbul ignore if */
-        if (process.env.NODE_ENV !== 'production' && type === 'component') {
-          validateComponentName(id)
-        }
-        if (type === 'component' && isPlainObject(definition)) {
-          definition.name = definition.name || id
-          definition = this.options._base.extend(definition)
-        }
-        if (type === 'directive' && typeof definition === 'function') {
-          definition = { bind: definition, update: definition }
-        }
-        this.options[type + 's'][id] = definition
-        return definition
-      }
-    }
-  })
-}
diff --git a/1.Vue/src/core/global-api/extend.js b/1.Vue/src/core/global-api/extend.js
deleted file mode 100644
index c1bbda3..0000000
--- a/1.Vue/src/core/global-api/extend.js
+++ /dev/null
@@ -1,95 +0,0 @@
-/* @flow */
-
-import { ASSET_TYPES } from 'shared/constants'
-import { defineComputed, proxy } from '../instance/state'
-import { extend, mergeOptions, validateComponentName } from '../util/index'
-
-export function initExtend (Vue: GlobalAPI) {
-  /**
-   * Each instance constructor, including Vue, has a unique
-   * cid. This enables us to create wrapped "child
-   * constructors" for prototypal inheritance and cache them.
-   */
-  Vue.cid = 0
-  let cid = 1
-
-  /**
-   * Class inheritance
-   */
-  Vue.extend = function (extendOptions: Object): Function {
-    extendOptions = extendOptions || {}
-    const Super = this
-    const SuperId = Super.cid
-    const cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {})
-    if (cachedCtors[SuperId]) {
-      return cachedCtors[SuperId]
-    }
-
-    const name = extendOptions.name || Super.options.name
-    if (process.env.NODE_ENV !== 'production' && name) {
-      validateComponentName(name)
-    }
-
-    const Sub = function VueComponent (options) {
-      this._init(options)
-    }
-    Sub.prototype = Object.create(Super.prototype)
-    Sub.prototype.constructor = Sub
-    Sub.cid = cid++
-    Sub.options = mergeOptions(
-      Super.options,
-      extendOptions
-    )
-    Sub['super'] = Super
-
-    // For props and computed properties, we define the proxy getters on
-    // the Vue instances at extension time, on the extended prototype. This
-    // avoids Object.defineProperty calls for each instance created.
-    if (Sub.options.props) {
-      initProps(Sub)
-    }
-    if (Sub.options.computed) {
-      initComputed(Sub)
-    }
-
-    // allow further extension/mixin/plugin usage
-    Sub.extend = Super.extend
-    Sub.mixin = Super.mixin
-    Sub.use = Super.use
-
-    // create asset registers, so extended classes
-    // can have their private assets too.
-    ASSET_TYPES.forEach(function (type) {
-      Sub[type] = Super[type]
-    })
-    // enable recursive self-lookup
-    if (name) {
-      Sub.options.components[name] = Sub
-    }
-
-    // keep a reference to the super options at extension time.
-    // later at instantiation we can check if Super's options have
-    // been updated.
-    Sub.superOptions = Super.options
-    Sub.extendOptions = extendOptions
-    Sub.sealedOptions = extend({}, Sub.options)
-
-    // cache constructor
-    cachedCtors[SuperId] = Sub
-    return Sub
-  }
-}
-
-function initProps (Comp) {
-  const props = Comp.options.props
-  for (const key in props) {
-    proxy(Comp.prototype, `_props`, key)
-  }
-}
-
-function initComputed (Comp) {
-  const computed = Comp.options.computed
-  for (const key in computed) {
-    defineComputed(Comp.prototype, key, computed[key])
-  }
-}
diff --git a/1.Vue/src/core/global-api/index.js b/1.Vue/src/core/global-api/index.js
deleted file mode 100644
index b3387a8..0000000
--- a/1.Vue/src/core/global-api/index.js
+++ /dev/null
@@ -1,69 +0,0 @@
-/* @flow */
-
-import config from '../config'
-import { initUse } from './use'
-import { initMixin } from './mixin'
-import { initExtend } from './extend'
-import { initAssetRegisters } from './assets'
-import { set, del } from '../observer/index'
-import { ASSET_TYPES } from 'shared/constants'
-import builtInComponents from '../components/index'
-import { observe } from 'core/observer/index'
-
-import {
-  warn,
-  extend,
-  nextTick,
-  mergeOptions,
-  defineReactive
-} from '../util/index'
-
-export function initGlobalAPI (Vue: GlobalAPI) {
-  // config
-  const configDef = {}
-  configDef.get = () => config
-  if (process.env.NODE_ENV !== 'production') {
-    configDef.set = () => {
-      warn(
-        'Do not replace the Vue.config object, set individual fields instead.'
-      )
-    }
-  }
-  Object.defineProperty(Vue, 'config', configDef)
-
-  // exposed util methods.
-  // NOTE: these are not considered part of the public API - avoid relying on
-  // them unless you are aware of the risk.
-  Vue.util = {
-    warn,
-    extend,
-    mergeOptions,
-    defineReactive
-  }
-
-  Vue.set = set
-  Vue.delete = del
-  Vue.nextTick = nextTick
-
-  // 2.6 explicit observable API
-  Vue.observable = <T>(obj: T): T => {
-    observe(obj)
-    return obj
-  }
-
-  Vue.options = Object.create(null)
-  ASSET_TYPES.forEach(type => {
-    Vue.options[type + 's'] = Object.create(null)
-  })
-
-  // this is used to identify the "base" constructor to extend all plain-object
-  // components with in Weex's multi-instance scenarios.
-  Vue.options._base = Vue
-
-  extend(Vue.options.components, builtInComponents)
-
-  initUse(Vue)
-  initMixin(Vue)
-  initExtend(Vue)
-  initAssetRegisters(Vue)
-}
diff --git a/1.Vue/src/core/global-api/mixin.js b/1.Vue/src/core/global-api/mixin.js
deleted file mode 100644
index 36017a3..0000000
--- a/1.Vue/src/core/global-api/mixin.js
+++ /dev/null
@@ -1,10 +0,0 @@
-/* @flow */
-
-import { mergeOptions } from '../util/index'
-
-export function initMixin (Vue: GlobalAPI) {
-  Vue.mixin = function (mixin: Object) {
-    this.options = mergeOptions(this.options, mixin)
-    return this
-  }
-}
diff --git a/1.Vue/src/core/global-api/use.js b/1.Vue/src/core/global-api/use.js
deleted file mode 100644
index a5b6998..0000000
--- a/1.Vue/src/core/global-api/use.js
+++ /dev/null
@@ -1,23 +0,0 @@
-/* @flow */
-
-import { toArray } from '../util/index'
-
-export function initUse (Vue: GlobalAPI) {
-  Vue.use = function (plugin: Function | Object) {
-    const installedPlugins = (this._installedPlugins || (this._installedPlugins = []))
-    if (installedPlugins.indexOf(plugin) > -1) {
-      return this
-    }
-
-    // additional parameters
-    const args = toArray(arguments, 1)
-    args.unshift(this)
-    if (typeof plugin.install === 'function') {
-      plugin.install.apply(plugin, args)
-    } else if (typeof plugin === 'function') {
-      plugin.apply(null, args)
-    }
-    installedPlugins.push(plugin)
-    return this
-  }
-}
diff --git a/1.Vue/src/core/index.js b/1.Vue/src/core/index.js
deleted file mode 100644
index daf6203..0000000
--- a/1.Vue/src/core/index.js
+++ /dev/null
@@ -1,26 +0,0 @@
-import Vue from './instance/index'
-import { initGlobalAPI } from './global-api/index'
-import { isServerRendering } from 'core/util/env'
-import { FunctionalRenderContext } from 'core/vdom/create-functional-component'
-
-initGlobalAPI(Vue)
-
-Object.defineProperty(Vue.prototype, '$isServer', {
-  get: isServerRendering
-})
-
-Object.defineProperty(Vue.prototype, '$ssrContext', {
-  get () {
-    /* istanbul ignore next */
-    return this.$vnode && this.$vnode.ssrContext
-  }
-})
-
-// expose FunctionalRenderContext for ssr runtime helper installation
-Object.defineProperty(Vue, 'FunctionalRenderContext', {
-  value: FunctionalRenderContext
-})
-
-Vue.version = '__VERSION__'
-
-export default Vue
diff --git a/1.Vue/src/core/instance/events.js b/1.Vue/src/core/instance/events.js
deleted file mode 100644
index 4d5bb55..0000000
--- a/1.Vue/src/core/instance/events.js
+++ /dev/null
@@ -1,143 +0,0 @@
-/* @flow */
-
-import {
-  tip,
-  toArray,
-  hyphenate,
-  formatComponentName,
-  invokeWithErrorHandling
-} from '../util/index'
-import { updateListeners } from '../vdom/helpers/index'
-
-export function initEvents (vm: Component) {
-  vm._events = Object.create(null)
-  vm._hasHookEvent = false
-  // init parent attached events
-  const listeners = vm.$options._parentListeners
-  if (listeners) {
-    updateComponentListeners(vm, listeners)
-  }
-}
-
-let target: any
-
-function add (event, fn) {
-  target.$on(event, fn)
-}
-
-function remove (event, fn) {
-  target.$off(event, fn)
-}
-
-function createOnceHandler (event, fn) {
-  const _target = target
-  return function onceHandler () {
-    const res = fn.apply(null, arguments)
-    if (res !== null) {
-      _target.$off(event, onceHandler)
-    }
-  }
-}
-
-export function updateComponentListeners (
-  vm: Component,
-  listeners: Object,
-  oldListeners: ?Object
-) {
-  target = vm
-  updateListeners(listeners, oldListeners || {}, add, remove, createOnceHandler, vm)
-  target = undefined
-}
-
-export function eventsMixin (Vue: Class<Component>) {
-  const hookRE = /^hook:/
-  Vue.prototype.$on = function (event: string | Array<string>, fn: Function): Component {
-    const vm: Component = this
-    if (Array.isArray(event)) {
-      for (let i = 0, l = event.length; i < l; i++) {
-        vm.$on(event[i], fn)
-      }
-    } else {
-      (vm._events[event] || (vm._events[event] = [])).push(fn)
-      // optimize hook:event cost by using a boolean flag marked at registration
-      // instead of a hash lookup
-      if (hookRE.test(event)) {
-        vm._hasHookEvent = true
-      }
-    }
-    return vm
-  }
-
-  Vue.prototype.$once = function (event: string, fn: Function): Component {
-    const vm: Component = this
-    function on () {
-      vm.$off(event, on)
-      fn.apply(vm, arguments)
-    }
-    on.fn = fn
-    vm.$on(event, on)
-    return vm
-  }
-
-  Vue.prototype.$off = function (event?: string | Array<string>, fn?: Function): Component {
-    const vm: Component = this
-    // all
-    if (!arguments.length) {
-      vm._events = Object.create(null)
-      return vm
-    }
-    // array of events
-    if (Array.isArray(event)) {
-      for (let i = 0, l = event.length; i < l; i++) {
-        vm.$off(event[i], fn)
-      }
-      return vm
-    }
-    // specific event
-    const cbs = vm._events[event]
-    if (!cbs) {
-      return vm
-    }
-    if (!fn) {
-      vm._events[event] = null
-      return vm
-    }
-    // specific handler
-    let cb
-    let i = cbs.length
-    while (i--) {
-      cb = cbs[i]
-      if (cb === fn || cb.fn === fn) {
-        cbs.splice(i, 1)
-        break
-      }
-    }
-    return vm
-  }
-
-  Vue.prototype.$emit = function (event: string): Component {
-    const vm: Component = this
-    if (process.env.NODE_ENV !== 'production') {
-      const lowerCaseEvent = event.toLowerCase()
-      if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
-        tip(
-          `Event "${lowerCaseEvent}" is emitted in component ` +
-          `${formatComponentName(vm)} but the handler is registered for "${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 "${hyphenate(event)}" instead of "${event}".`
-        )
-      }
-    }
-    let cbs = vm._events[event]
-    if (cbs) {
-      cbs = cbs.length > 1 ? toArray(cbs) : cbs
-      const args = toArray(arguments, 1)
-      const info = `event handler for "${event}"`
-      for (let i = 0, l = cbs.length; i < l; i++) {
-        invokeWithErrorHandling(cbs[i], vm, args, vm, info)
-      }
-    }
-    return vm
-  }
-}
diff --git a/1.Vue/src/core/instance/index.js b/1.Vue/src/core/instance/index.js
deleted file mode 100644
index 8a44023..0000000
--- a/1.Vue/src/core/instance/index.js
+++ /dev/null
@@ -1,23 +0,0 @@
-import { initMixin } from './init'
-import { stateMixin } from './state'
-import { renderMixin } from './render'
-import { eventsMixin } from './events'
-import { lifecycleMixin } from './lifecycle'
-import { warn } from '../util/index'
-
-function Vue (options) {
-  if (process.env.NODE_ENV !== 'production' &&
-    !(this instanceof Vue)
-  ) {
-    warn('Vue is a constructor and should be called with the `new` keyword')
-  }
-  this._init(options)
-}
-
-initMixin(Vue)
-stateMixin(Vue)
-eventsMixin(Vue)
-lifecycleMixin(Vue)
-renderMixin(Vue)
-
-export default Vue
diff --git a/1.Vue/src/core/instance/init.js b/1.Vue/src/core/instance/init.js
deleted file mode 100644
index 7c5ab2d..0000000
--- a/1.Vue/src/core/instance/init.js
+++ /dev/null
@@ -1,128 +0,0 @@
-/* @flow */
-
-import config from '../config'
-import { initProxy } from './proxy'
-import { initState } from './state'
-import { initRender } from './render'
-import { initEvents } from './events'
-import { mark, measure } from '../util/perf'
-import { initLifecycle, callHook } from './lifecycle'
-import { initProvide, initInjections } from './inject'
-import { extend, mergeOptions, formatComponentName } from '../util/index'
-
-let uid = 0
-
-export function initMixin (Vue: Class<Component>) {
-  Vue.prototype._init = function (options?: Object) {
-    const vm: Component = this
-    // a uid
-    vm._uid = uid++
-
-    let startTag, endTag
-    /* istanbul ignore if */
-    if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
-      startTag = `vue-perf-start:${vm._uid}`
-      endTag = `vue-perf-end:${vm._uid}`
-      mark(startTag)
-    }
-
-    // a flag to avoid this being observed
-    vm._isVue = true
-    // merge options
-    if (options && options._isComponent) {
-      // optimize internal component instantiation
-      // since dynamic options merging is pretty slow, and none of the
-      // internal component options needs special treatment.
-      initInternalComponent(vm, options)
-    } else {
-      vm.$options = mergeOptions(
-        resolveConstructorOptions(vm.constructor),
-        options || {},
-        vm
-      )
-    }
-    /* istanbul ignore else */
-    if (process.env.NODE_ENV !== 'production') {
-      initProxy(vm)
-    } else {
-      vm._renderProxy = vm
-    }
-    // expose real self
-    vm._self = vm
-    initLifecycle(vm)
-    initEvents(vm)
-    initRender(vm)
-    callHook(vm, 'beforeCreate')
-    initInjections(vm) // resolve injections before data/props
-    initState(vm)
-    initProvide(vm) // resolve provide after data/props
-    callHook(vm, 'created')
-
-    /* istanbul ignore if */
-    if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
-      vm._name = formatComponentName(vm, false)
-      mark(endTag)
-      measure(`vue ${vm._name} init`, startTag, endTag)
-    }
-
-    if (vm.$options.el) {
-      vm.$mount(vm.$options.el)
-    }
-  }
-}
-
-export function initInternalComponent (vm: Component, options: InternalComponentOptions) {
-  const opts = vm.$options = Object.create(vm.constructor.options)
-  // doing this because it's faster than dynamic enumeration.
-  const parentVnode = options._parentVnode
-  opts.parent = options.parent
-  opts._parentVnode = parentVnode
-
-  const vnodeComponentOptions = parentVnode.componentOptions
-  opts.propsData = vnodeComponentOptions.propsData
-  opts._parentListeners = vnodeComponentOptions.listeners
-  opts._renderChildren = vnodeComponentOptions.children
-  opts._componentTag = vnodeComponentOptions.tag
-
-  if (options.render) {
-    opts.render = options.render
-    opts.staticRenderFns = options.staticRenderFns
-  }
-}
-
-export function resolveConstructorOptions (Ctor: Class<Component>) {
-  let options = Ctor.options
-  if (Ctor.super) {
-    const superOptions = resolveConstructorOptions(Ctor.super)
-    const cachedSuperOptions = Ctor.superOptions
-    if (superOptions !== cachedSuperOptions) {
-      // super option changed,
-      // need to resolve new options.
-      Ctor.superOptions = superOptions
-      // check if there are any late-modified/attached options (#4976)
-      const modifiedOptions = resolveModifiedOptions(Ctor)
-      // update base extend options
-      if (modifiedOptions) {
-        extend(Ctor.extendOptions, modifiedOptions)
-      }
-      options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions)
-      if (options.name) {
-        options.components[options.name] = Ctor
-      }
-    }
-  }
-  return options
-}
-
-function resolveModifiedOptions (Ctor: Class<Component>): ?Object {
-  let modified
-  const latest = Ctor.options
-  const sealed = Ctor.sealedOptions
-  for (const key in latest) {
-    if (latest[key] !== sealed[key]) {
-      if (!modified) modified = {}
-      modified[key] = latest[key]
-    }
-  }
-  return modified
-}
diff --git a/1.Vue/src/core/instance/inject.js b/1.Vue/src/core/instance/inject.js
deleted file mode 100644
index b04184e..0000000
--- a/1.Vue/src/core/instance/inject.js
+++ /dev/null
@@ -1,73 +0,0 @@
-/* @flow */
-
-import { hasOwn } from 'shared/util'
-import { warn, hasSymbol } from '../util/index'
-import { defineReactive, toggleObserving } from '../observer/index'
-
-export function initProvide (vm: Component) {
-  const provide = vm.$options.provide
-  if (provide) {
-    vm._provided = typeof provide === 'function'
-      ? provide.call(vm)
-      : provide
-  }
-}
-
-export function initInjections (vm: Component) {
-  const result = resolveInject(vm.$options.inject, vm)
-  if (result) {
-    toggleObserving(false)
-    Object.keys(result).forEach(key => {
-      /* istanbul ignore else */
-      if (process.env.NODE_ENV !== 'production') {
-        defineReactive(vm, key, result[key], () => {
-          warn(
-            `Avoid mutating an injected value directly since the changes will be ` +
-            `overwritten whenever the provided component re-renders. ` +
-            `injection being mutated: "${key}"`,
-            vm
-          )
-        })
-      } else {
-        defineReactive(vm, key, result[key])
-      }
-    })
-    toggleObserving(true)
-  }
-}
-
-export function resolveInject (inject: any, vm: Component): ?Object {
-  if (inject) {
-    // inject is :any because flow is not smart enough to figure out cached
-    const result = Object.create(null)
-    const keys = hasSymbol
-      ? Reflect.ownKeys(inject)
-      : Object.keys(inject)
-
-    for (let i = 0; i < keys.length; i++) {
-      const key = keys[i]
-      // #6574 in case the inject object is observed...
-      if (key === '__ob__') continue
-      const provideKey = inject[key].from
-      let source = vm
-      while (source) {
-        if (source._provided && hasOwn(source._provided, provideKey)) {
-          result[key] = source._provided[provideKey]
-          break
-        }
-        source = source.$parent
-      }
-      if (!source) {
-        if ('default' in inject[key]) {
-          const provideDefault = inject[key].default
-          result[key] = typeof provideDefault === 'function'
-            ? provideDefault.call(vm)
-            : provideDefault
-        } else if (process.env.NODE_ENV !== 'production') {
-          warn(`Injection "${key}" not found`, vm)
-        }
-      }
-    }
-    return result
-  }
-}
diff --git a/1.Vue/src/core/instance/lifecycle.js b/1.Vue/src/core/instance/lifecycle.js
deleted file mode 100644
index b7265df..0000000
--- a/1.Vue/src/core/instance/lifecycle.js
+++ /dev/null
@@ -1,350 +0,0 @@
-/* @flow */
-
-import config from '../config'
-import Watcher from '../observer/watcher'
-import { mark, measure } from '../util/perf'
-import { createEmptyVNode } from '../vdom/vnode'
-import { updateComponentListeners } from './events'
-import { resolveSlots } from './render-helpers/resolve-slots'
-import { toggleObserving } from '../observer/index'
-import { pushTarget, popTarget } from '../observer/dep'
-
-import {
-  warn,
-  noop,
-  remove,
-  emptyObject,
-  validateProp,
-  invokeWithErrorHandling
-} from '../util/index'
-
-export let activeInstance: any = null
-export let isUpdatingChildComponent: boolean = false
-
-export function setActiveInstance(vm: Component) {
-  const prevActiveInstance = activeInstance
-  activeInstance = vm
-  return () => {
-    activeInstance = prevActiveInstance
-  }
-}
-
-export function initLifecycle (vm: Component) {
-  const options = vm.$options
-
-  // locate first non-abstract parent
-  let parent = options.parent
-  if (parent && !options.abstract) {
-    while (parent.$options.abstract && parent.$parent) {
-      parent = parent.$parent
-    }
-    parent.$children.push(vm)
-  }
-
-  vm.$parent = parent
-  vm.$root = parent ? parent.$root : vm
-
-  vm.$children = []
-  vm.$refs = {}
-
-  vm._watcher = null
-  vm._inactive = null
-  vm._directInactive = false
-  vm._isMounted = false
-  vm._isDestroyed = false
-  vm._isBeingDestroyed = false
-}
-
-export function lifecycleMixin (Vue: Class<Component>) {
-  Vue.prototype._update = function (vnode: VNode, hydrating?: boolean) {
-    const vm: Component = this
-    const prevEl = vm.$el
-    const prevVnode = vm._vnode
-    const restoreActiveInstance = setActiveInstance(vm)
-    vm._vnode = vnode
-    // Vue.prototype.__patch__ is injected in entry points
-    // based on the rendering backend used.
-    if (!prevVnode) {
-      // initial render
-      vm.$el = vm.__patch__(vm.$el, vnode, hydrating, false /* removeOnly */)
-    } else {
-      // updates
-      vm.$el = vm.__patch__(prevVnode, vnode)
-    }
-    restoreActiveInstance()
-    // update __vue__ reference
-    if (prevEl) {
-      prevEl.__vue__ = null
-    }
-    if (vm.$el) {
-      vm.$el.__vue__ = vm
-    }
-    // if parent is an HOC, update its $el as well
-    if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {
-      vm.$parent.$el = vm.$el
-    }
-    // updated hook is called by the scheduler to ensure that children are
-    // updated in a parent's updated hook.
-  }
-
-  Vue.prototype.$forceUpdate = function () {
-    const vm: Component = this
-    if (vm._watcher) {
-      vm._watcher.update()
-    }
-  }
-
-  Vue.prototype.$destroy = function () {
-    const vm: Component = this
-    if (vm._isBeingDestroyed) {
-      return
-    }
-    callHook(vm, 'beforeDestroy')
-    vm._isBeingDestroyed = true
-    // remove self from parent
-    const parent = vm.$parent
-    if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
-      remove(parent.$children, vm)
-    }
-    // teardown watchers
-    if (vm._watcher) {
-      vm._watcher.teardown()
-    }
-    let i = vm._watchers.length
-    while (i--) {
-      vm._watchers[i].teardown()
-    }
-    // remove reference from data ob
-    // frozen object may not have observer.
-    if (vm._data.__ob__) {
-      vm._data.__ob__.vmCount--
-    }
-    // call the last hook...
-    vm._isDestroyed = true
-    // invoke destroy hooks on current rendered tree
-    vm.__patch__(vm._vnode, null)
-    // fire destroyed hook
-    callHook(vm, 'destroyed')
-    // turn off all instance listeners.
-    vm.$off()
-    // remove __vue__ reference
-    if (vm.$el) {
-      vm.$el.__vue__ = null
-    }
-    // release circular reference (#6759)
-    if (vm.$vnode) {
-      vm.$vnode.parent = null
-    }
-  }
-}
-
-export function mountComponent (
-  vm: Component,
-  el: ?Element,
-  hydrating?: boolean
-): Component {
-  vm.$el = el
-  if (!vm.$options.render) {
-    vm.$options.render = createEmptyVNode
-    if (process.env.NODE_ENV !== 'production') {
-      /* istanbul ignore if */
-      if ((vm.$options.template && vm.$options.template.charAt(0) !== '#') ||
-        vm.$options.el || el) {
-        warn(
-          'You are using the runtime-only build of Vue where the template ' +
-          'compiler is not available. Either pre-compile the templates into ' +
-          'render functions, or use the compiler-included build.',
-          vm
-        )
-      } else {
-        warn(
-          'Failed to mount component: template or render function not defined.',
-          vm
-        )
-      }
-    }
-  }
-  callHook(vm, 'beforeMount')
-
-  let updateComponent
-  /* istanbul ignore if */
-  if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
-    updateComponent = () => {
-      const name = vm._name
-      const id = vm._uid
-      const startTag = `vue-perf-start:${id}`
-      const endTag = `vue-perf-end:${id}`
-
-      mark(startTag)
-      const vnode = vm._render()
-      mark(endTag)
-      measure(`vue ${name} render`, startTag, endTag)
-
-      mark(startTag)
-      vm._update(vnode, hydrating)
-      mark(endTag)
-      measure(`vue ${name} patch`, startTag, endTag)
-    }
-  } else {
-    updateComponent = () => {
-      vm._update(vm._render(), hydrating)
-    }
-  }
-
-  // we set this to vm._watcher inside the watcher's constructor
-  // since the watcher's initial patch may call $forceUpdate (e.g. inside child
-  // component's mounted hook), which relies on vm._watcher being already defined
-  new Watcher(vm, updateComponent, noop, {
-    before () {
-      if (vm._isMounted && !vm._isDestroyed) {
-        callHook(vm, 'beforeUpdate')
-      }
-    }
-  }, true /* isRenderWatcher */)
-  hydrating = false
-
-  // manually mounted instance, call mounted on self
-  // mounted is called for render-created child components in its inserted hook
-  if (vm.$vnode == null) {
-    vm._isMounted = true
-    callHook(vm, 'mounted')
-  }
-  return vm
-}
-
-export function updateChildComponent (
-  vm: Component,
-  propsData: ?Object,
-  listeners: ?Object,
-  parentVnode: MountedComponentVNode,
-  renderChildren: ?Array<VNode>
-) {
-  if (process.env.NODE_ENV !== 'production') {
-    isUpdatingChildComponent = true
-  }
-
-  // determine whether component has slot children
-  // we need to do this before overwriting $options._renderChildren.
-
-  // check if there are dynamic scopedSlots (hand-written or compiled but with
-  // dynamic slot names). Static scoped slots compiled from template has the
-  // "$stable" marker.
-  const newScopedSlots = parentVnode.data.scopedSlots
-  const oldScopedSlots = vm.$scopedSlots
-  const hasDynamicScopedSlot = !!(
-    (newScopedSlots && !newScopedSlots.$stable) ||
-    (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
-    (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key)
-  )
-
-  // Any static slot children from the parent may have changed during parent's
-  // update. Dynamic scoped slots may also have changed. In such cases, a forced
-  // update is necessary to ensure correctness.
-  const needsForceUpdate = !!(
-    renderChildren ||               // has new static slots
-    vm.$options._renderChildren ||  // has old static slots
-    hasDynamicScopedSlot
-  )
-
-  vm.$options._parentVnode = parentVnode
-  vm.$vnode = parentVnode // update vm's placeholder node without re-render
-
-  if (vm._vnode) { // update child tree's parent
-    vm._vnode.parent = parentVnode
-  }
-  vm.$options._renderChildren = renderChildren
-
-  // update $attrs and $listeners hash
-  // these are also reactive so they may trigger child update if the child
-  // used them during render
-  vm.$attrs = parentVnode.data.attrs || emptyObject
-  vm.$listeners = listeners || emptyObject
-
-  // update props
-  if (propsData && vm.$options.props) {
-    toggleObserving(false)
-    const props = vm._props
-    const propKeys = vm.$options._propKeys || []
-    for (let i = 0; i < propKeys.length; i++) {
-      const key = propKeys[i]
-      const propOptions: any = vm.$options.props // wtf flow?
-      props[key] = validateProp(key, propOptions, propsData, vm)
-    }
-    toggleObserving(true)
-    // keep a copy of raw propsData
-    vm.$options.propsData = propsData
-  }
-
-  // update listeners
-  listeners = listeners || emptyObject
-  const oldListeners = vm.$options._parentListeners
-  vm.$options._parentListeners = listeners
-  updateComponentListeners(vm, listeners, oldListeners)
-
-  // resolve slots + force update if has children
-  if (needsForceUpdate) {
-    vm.$slots = resolveSlots(renderChildren, parentVnode.context)
-    vm.$forceUpdate()
-  }
-
-  if (process.env.NODE_ENV !== 'production') {
-    isUpdatingChildComponent = false
-  }
-}
-
-function isInInactiveTree (vm) {
-  while (vm && (vm = vm.$parent)) {
-    if (vm._inactive) return true
-  }
-  return false
-}
-
-export function activateChildComponent (vm: Component, direct?: boolean) {
-  if (direct) {
-    vm._directInactive = false
-    if (isInInactiveTree(vm)) {
-      return
-    }
-  } else if (vm._directInactive) {
-    return
-  }
-  if (vm._inactive || vm._inactive === null) {
-    vm._inactive = false
-    for (let i = 0; i < vm.$children.length; i++) {
-      activateChildComponent(vm.$children[i])
-    }
-    callHook(vm, 'activated')
-  }
-}
-
-export function deactivateChildComponent (vm: Component, direct?: boolean) {
-  if (direct) {
-    vm._directInactive = true
-    if (isInInactiveTree(vm)) {
-      return
-    }
-  }
-  if (!vm._inactive) {
-    vm._inactive = true
-    for (let i = 0; i < vm.$children.length; i++) {
-      deactivateChildComponent(vm.$children[i])
-    }
-    callHook(vm, 'deactivated')
-  }
-}
-
-export function callHook (vm: Component, hook: string) {
-  // #7573 disable dep collection when invoking lifecycle hooks
-  pushTarget()
-  const handlers = vm.$options[hook]
-  const info = `${hook} hook`
-  if (handlers) {
-    for (let i = 0, j = handlers.length; i < j; i++) {
-      invokeWithErrorHandling(handlers[i], vm, null, vm, info)
-    }
-  }
-  if (vm._hasHookEvent) {
-    vm.$emit('hook:' + hook)
-  }
-  popTarget()
-}
diff --git a/1.Vue/src/core/instance/proxy.js b/1.Vue/src/core/instance/proxy.js
deleted file mode 100644
index 08d9651..0000000
--- a/1.Vue/src/core/instance/proxy.js
+++ /dev/null
@@ -1,92 +0,0 @@
-/* not type checking this file because flow doesn't play well with Proxy */
-
-import config from 'core/config'
-import { warn, makeMap, isNative } from '../util/index'
-
-let initProxy
-
-if (process.env.NODE_ENV !== 'production') {
-  const allowedGlobals = makeMap(
-    'Infinity,undefined,NaN,isFinite,isNaN,' +
-    'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
-    'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,' +
-    'require' // for Webpack/Browserify
-  )
-
-  const warnNonPresent = (target, key) => {
-    warn(
-      `Property or method "${key}" is not defined on the instance but ` +
-      'referenced during render. Make sure that this property is reactive, ' +
-      'either in the data option, or for class-based components, by ' +
-      'initializing the property. ' +
-      'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.',
-      target
-    )
-  }
-
-  const warnReservedPrefix = (target, key) => {
-    warn(
-      `Property "${key}" must be accessed with "$data.${key}" because ` +
-      'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
-      'prevent conflicts with Vue internals' +
-      'See: https://vuejs.org/v2/api/#data',
-      target
-    )
-  }
-
-  const hasProxy =
-    typeof Proxy !== 'undefined' && isNative(Proxy)
-
-  if (hasProxy) {
-    const isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact')
-    config.keyCodes = new Proxy(config.keyCodes, {
-      set (target, key, value) {
-        if (isBuiltInModifier(key)) {
-          warn(`Avoid overwriting built-in modifier in config.keyCodes: .${key}`)
-          return false
-        } else {
-          target[key] = value
-          return true
-        }
-      }
-    })
-  }
-
-  const hasHandler = {
-    has (target, key) {
-      const has = key in target
-      const isAllowed = allowedGlobals(key) ||
-        (typeof key === 'string' && key.charAt(0) === '_' && !(key in target.$data))
-      if (!has && !isAllowed) {
-        if (key in target.$data) warnReservedPrefix(target, key)
-        else warnNonPresent(target, key)
-      }
-      return has || !isAllowed
-    }
-  }
-
-  const getHandler = {
-    get (target, key) {
-      if (typeof key === 'string' && !(key in target)) {
-        if (key in target.$data) warnReservedPrefix(target, key)
-        else warnNonPresent(target, key)
-      }
-      return target[key]
-    }
-  }
-
-  initProxy = function initProxy (vm) {
-    if (hasProxy) {
-      // determine which proxy handler to use
-      const options = vm.$options
-      const handlers = options.render && options.render._withStripped
-        ? getHandler
-        : hasHandler
-      vm._renderProxy = new Proxy(vm, handlers)
-    } else {
-      vm._renderProxy = vm
-    }
-  }
-}
-
-export { initProxy }
diff --git a/1.Vue/src/core/instance/render-helpers/bind-dynamic-keys.js b/1.Vue/src/core/instance/render-helpers/bind-dynamic-keys.js
deleted file mode 100644
index ff37fc4..0000000
--- a/1.Vue/src/core/instance/render-helpers/bind-dynamic-keys.js
+++ /dev/null
@@ -1,35 +0,0 @@
-/* @flow */
-
-// helper to process dynamic keys for dynamic arguments in v-bind and v-on.
-// For example, the following template:
-//
-// <div id="foo" :[key]="value">
-//
-// compiles to the following:
-//
-// _c('div', { attrs: bindDynamicKeys({ "id": "app" }, [key, value]) })
-
-import { warn } from 'core/util/debug'
-
-export function bindDynamicKeys (baseObj: Object, values: Array<any>): Object {
-  for (let i = 0; i < values.length; i += 2) {
-    const key = values[i]
-    if (typeof key === 'string' && key) {
-      baseObj[values[i]] = values[i + 1]
-    } else if (process.env.NODE_ENV !== 'production' && key !== '' && key !== null) {
-      // null is a speical value for explicitly removing a binding
-      warn(
-        `Invalid value for dynamic directive argument (expected string or null): ${key}`,
-        this
-      )
-    }
-  }
-  return baseObj
-}
-
-// helper to dynamically append modifier runtime markers to event names.
-// ensure only append when value is already string, otherwise it will be cast
-// to string and cause the type check to miss.
-export function prependModifier (value: any, symbol: string): any {
-  return typeof value === 'string' ? symbol + value : value
-}
diff --git a/1.Vue/src/core/instance/render-helpers/bind-object-listeners.js b/1.Vue/src/core/instance/render-helpers/bind-object-listeners.js
deleted file mode 100644
index 5bfc751..0000000
--- a/1.Vue/src/core/instance/render-helpers/bind-object-listeners.js
+++ /dev/null
@@ -1,22 +0,0 @@
-/* @flow */
-
-import { warn, extend, isPlainObject } from 'core/util/index'
-
-export function bindObjectListeners (data: any, value: any): VNodeData {
-  if (value) {
-    if (!isPlainObject(value)) {
-      process.env.NODE_ENV !== 'production' && warn(
-        'v-on without argument expects an Object value',
-        this
-      )
-    } else {
-      const on = data.on = data.on ? extend({}, data.on) : {}
-      for (const key in value) {
-        const existing = on[key]
-        const ours = value[key]
-        on[key] = existing ? [].concat(existing, ours) : ours
-      }
-    }
-  }
-  return data
-}
diff --git a/1.Vue/src/core/instance/render-helpers/bind-object-props.js b/1.Vue/src/core/instance/render-helpers/bind-object-props.js
deleted file mode 100644
index f1b34ae..0000000
--- a/1.Vue/src/core/instance/render-helpers/bind-object-props.js
+++ /dev/null
@@ -1,64 +0,0 @@
-/* @flow */
-
-import config from 'core/config'
-
-import {
-  warn,
-  isObject,
-  toObject,
-  isReservedAttribute,
-  camelize,
-  hyphenate
-} from 'core/util/index'
-
-/**
- * Runtime helper for merging v-bind="object" into a VNode's data.
- */
-export function bindObjectProps (
-  data: any,
-  tag: string,
-  value: any,
-  asProp: boolean,
-  isSync?: boolean
-): VNodeData {
-  if (value) {
-    if (!isObject(value)) {
-      process.env.NODE_ENV !== 'production' && warn(
-        'v-bind without argument expects an Object or Array value',
-        this
-      )
-    } else {
-      if (Array.isArray(value)) {
-        value = toObject(value)
-      }
-      let hash
-      for (const key in value) {
-        if (
-          key === 'class' ||
-          key === 'style' ||
-          isReservedAttribute(key)
-        ) {
-          hash = data
-        } else {
-          const type = data.attrs && data.attrs.type
-          hash = asProp || config.mustUseProp(tag, type, key)
-            ? data.domProps || (data.domProps = {})
-            : data.attrs || (data.attrs = {})
-        }
-        const camelizedKey = camelize(key)
-        const hyphenatedKey = hyphenate(key)
-        if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
-          hash[key] = value[key]
-
-          if (isSync) {
-            const on = data.on || (data.on = {})
-            on[`update:${key}`] = function ($event) {
-              value[key] = $event
-            }
-          }
-        }
-      }
-    }
-  }
-  return data
-}
diff --git a/1.Vue/src/core/instance/render-helpers/check-keycodes.js b/1.Vue/src/core/instance/render-helpers/check-keycodes.js
deleted file mode 100644
index c12402b..0000000
--- a/1.Vue/src/core/instance/render-helpers/check-keycodes.js
+++ /dev/null
@@ -1,34 +0,0 @@
-/* @flow */
-
-import config from 'core/config'
-import { hyphenate } from 'shared/util'
-
-function isKeyNotMatch<T> (expect: T | Array<T>, actual: T): boolean {
-  if (Array.isArray(expect)) {
-    return expect.indexOf(actual) === -1
-  } else {
-    return expect !== actual
-  }
-}
-
-/**
- * Runtime helper for checking keyCodes from config.
- * exposed as Vue.prototype._k
- * passing in eventKeyName as last argument separately for backwards compat
- */
-export function checkKeyCodes (
-  eventKeyCode: number,
-  key: string,
-  builtInKeyCode?: number | Array<number>,
-  eventKeyName?: string,
-  builtInKeyName?: string | Array<string>
-): ?boolean {
-  const mappedKeyCode = config.keyCodes[key] || builtInKeyCode
-  if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
-    return isKeyNotMatch(builtInKeyName, eventKeyName)
-  } else if (mappedKeyCode) {
-    return isKeyNotMatch(mappedKeyCode, eventKeyCode)
-  } else if (eventKeyName) {
-    return hyphenate(eventKeyName) !== key
-  }
-}
diff --git a/1.Vue/src/core/instance/render-helpers/index.js b/1.Vue/src/core/instance/render-helpers/index.js
deleted file mode 100644
index 04e7f9c..0000000
--- a/1.Vue/src/core/instance/render-helpers/index.js
+++ /dev/null
@@ -1,33 +0,0 @@
-/* @flow */
-
-import { toNumber, toString, looseEqual, looseIndexOf } from 'shared/util'
-import { createTextVNode, createEmptyVNode } from 'core/vdom/vnode'
-import { renderList } from './render-list'
-import { renderSlot } from './render-slot'
-import { resolveFilter } from './resolve-filter'
-import { checkKeyCodes } from './check-keycodes'
-import { bindObjectProps } from './bind-object-props'
-import { renderStatic, markOnce } from './render-static'
-import { bindObjectListeners } from './bind-object-listeners'
-import { resolveScopedSlots } from './resolve-scoped-slots'
-import { bindDynamicKeys, prependModifier } from './bind-dynamic-keys'
-
-export function installRenderHelpers (target: any) {
-  target._o = markOnce
-  target._n = toNumber
-  target._s = toString
-  target._l = renderList
-  target._t = renderSlot
-  target._q = looseEqual
-  target._i = looseIndexOf
-  target._m = renderStatic
-  target._f = resolveFilter
-  target._k = checkKeyCodes
-  target._b = bindObjectProps
-  target._v = createTextVNode
-  target._e = createEmptyVNode
-  target._u = resolveScopedSlots
-  target._g = bindObjectListeners
-  target._d = bindDynamicKeys
-  target._p = prependModifier
-}
diff --git a/1.Vue/src/core/instance/render-helpers/render-list.js b/1.Vue/src/core/instance/render-helpers/render-list.js
deleted file mode 100644
index cf68742..0000000
--- a/1.Vue/src/core/instance/render-helpers/render-list.js
+++ /dev/null
@@ -1,50 +0,0 @@
-/* @flow */
-
-import { isObject, isDef, hasSymbol } from 'core/util/index'
-
-/**
- * Runtime helper for rendering v-for lists.
- */
-export function renderList (
-  val: any,
-  render: (
-    val: any,
-    keyOrIndex: string | number,
-    index?: number
-  ) => VNode
-): ?Array<VNode> {
-  let ret: ?Array<VNode>, i, l, keys, key
-  if (Array.isArray(val) || typeof val === 'string') {
-    ret = new Array(val.length)
-    for (i = 0, l = val.length; i < l; i++) {
-      ret[i] = render(val[i], i)
-    }
-  } else if (typeof val === 'number') {
-    ret = new Array(val)
-    for (i = 0; i < val; i++) {
-      ret[i] = render(i + 1, i)
-    }
-  } else if (isObject(val)) {
-    if (hasSymbol && val[Symbol.iterator]) {
-      ret = []
-      const iterator: Iterator<any> = val[Symbol.iterator]()
-      let result = iterator.next()
-      while (!result.done) {
-        ret.push(render(result.value, ret.length))
-        result = iterator.next()
-      }
-    } else {
-      keys = Object.keys(val)
-      ret = new Array(keys.length)
-      for (i = 0, l = keys.length; i < l; i++) {
-        key = keys[i]
-        ret[i] = render(val[key], key, i)
-      }
-    }
-  }
-  if (!isDef(ret)) {
-    ret = []
-  }
-  (ret: any)._isVList = true
-  return ret
-}
diff --git a/1.Vue/src/core/instance/render-helpers/render-slot.js b/1.Vue/src/core/instance/render-helpers/render-slot.js
deleted file mode 100644
index 52221f4..0000000
--- a/1.Vue/src/core/instance/render-helpers/render-slot.js
+++ /dev/null
@@ -1,38 +0,0 @@
-/* @flow */
-
-import { extend, warn, isObject } from 'core/util/index'
-
-/**
- * Runtime helper for rendering <slot>
- */
-export function renderSlot (
-  name: string,
-  fallback: ?Array<VNode>,
-  props: ?Object,
-  bindObject: ?Object
-): ?Array<VNode> {
-  const scopedSlotFn = this.$scopedSlots[name]
-  let nodes
-  if (scopedSlotFn) { // scoped slot
-    props = props || {}
-    if (bindObject) {
-      if (process.env.NODE_ENV !== 'production' && !isObject(bindObject)) {
-        warn(
-          'slot v-bind without argument expects an Object',
-          this
-        )
-      }
-      props = extend(extend({}, bindObject), props)
-    }
-    nodes = scopedSlotFn(props) || fallback
-  } else {
-    nodes = this.$slots[name] || fallback
-  }
-
-  const target = props && props.slot
-  if (target) {
-    return this.$createElement('template', { slot: target }, nodes)
-  } else {
-    return nodes
-  }
-}
diff --git a/1.Vue/src/core/instance/render-helpers/render-static.js b/1.Vue/src/core/instance/render-helpers/render-static.js
deleted file mode 100644
index f56510b..0000000
--- a/1.Vue/src/core/instance/render-helpers/render-static.js
+++ /dev/null
@@ -1,60 +0,0 @@
-/* @flow */
-
-/**
- * Runtime helper for rendering static trees.
- */
-export function renderStatic (
-  index: number,
-  isInFor: boolean
-): VNode | Array<VNode> {
-  const cached = this._staticTrees || (this._staticTrees = [])
-  let tree = cached[index]
-  // if has already-rendered static tree and not inside v-for,
-  // we can reuse the same tree.
-  if (tree && !isInFor) {
-    return tree
-  }
-  // otherwise, render a fresh tree.
-  tree = cached[index] = this.$options.staticRenderFns[index].call(
-    this._renderProxy,
-    null,
-    this // for render fns generated for functional component templates
-  )
-  markStatic(tree, `__static__${index}`, false)
-  return tree
-}
-
-/**
- * Runtime helper for v-once.
- * Effectively it means marking the node as static with a unique key.
- */
-export function markOnce (
-  tree: VNode | Array<VNode>,
-  index: number,
-  key: string
-) {
-  markStatic(tree, `__once__${index}${key ? `_${key}` : ``}`, true)
-  return tree
-}
-
-function markStatic (
-  tree: VNode | Array<VNode>,
-  key: string,
-  isOnce: boolean
-) {
-  if (Array.isArray(tree)) {
-    for (let i = 0; i < tree.length; i++) {
-      if (tree[i] && typeof tree[i] !== 'string') {
-        markStaticNode(tree[i], `${key}_${i}`, isOnce)
-      }
-    }
-  } else {
-    markStaticNode(tree, key, isOnce)
-  }
-}
-
-function markStaticNode (node, key, isOnce) {
-  node.isStatic = true
-  node.key = key
-  node.isOnce = isOnce
-}
diff --git a/1.Vue/src/core/instance/render-helpers/resolve-filter.js b/1.Vue/src/core/instance/render-helpers/resolve-filter.js
deleted file mode 100644
index 08a81e1..0000000
--- a/1.Vue/src/core/instance/render-helpers/resolve-filter.js
+++ /dev/null
@@ -1,10 +0,0 @@
-/* @flow */
-
-import { identity, resolveAsset } from 'core/util/index'
-
-/**
- * Runtime helper for resolving filters
- */
-export function resolveFilter (id: string): Function {
-  return resolveAsset(this.$options, 'filters', id, true) || identity
-}
diff --git a/1.Vue/src/core/instance/render-helpers/resolve-scoped-slots.js b/1.Vue/src/core/instance/render-helpers/resolve-scoped-slots.js
deleted file mode 100644
index f11ca00..0000000
--- a/1.Vue/src/core/instance/render-helpers/resolve-scoped-slots.js
+++ /dev/null
@@ -1,27 +0,0 @@
-/* @flow */
-
-export function resolveScopedSlots (
-  fns: ScopedSlotsData, // see flow/vnode
-  res?: Object,
-  // the following are added in 2.6
-  hasDynamicKeys?: boolean,
-  contentHashKey?: number
-): { [key: string]: Function, $stable: boolean } {
-  res = res || { $stable: !hasDynamicKeys }
-  for (let i = 0; i < fns.length; i++) {
-    const slot = fns[i]
-    if (Array.isArray(slot)) {
-      resolveScopedSlots(slot, res, hasDynamicKeys)
-    } else if (slot) {
-      // marker for reverse proxying v-slot without scope on this.$slots
-      if (slot.proxy) {
-        slot.fn.proxy = true
-      }
-      res[slot.key] = slot.fn
-    }
-  }
-  if (contentHashKey) {
-    (res: any).$key = contentHashKey
-  }
-  return res
-}
diff --git a/1.Vue/src/core/instance/render-helpers/resolve-slots.js b/1.Vue/src/core/instance/render-helpers/resolve-slots.js
deleted file mode 100644
index b4f2ef0..0000000
--- a/1.Vue/src/core/instance/render-helpers/resolve-slots.js
+++ /dev/null
@@ -1,50 +0,0 @@
-/* @flow */
-
-import type VNode from 'core/vdom/vnode'
-
-/**
- * Runtime helper for resolving raw children VNodes into a slot object.
- */
-export function resolveSlots (
-  children: ?Array<VNode>,
-  context: ?Component
-): { [key: string]: Array<VNode> } {
-  if (!children || !children.length) {
-    return {}
-  }
-  const slots = {}
-  for (let i = 0, l = children.length; i < l; i++) {
-    const child = children[i]
-    const data = child.data
-    // remove slot attribute if the node is resolved as a Vue slot node
-    if (data && data.attrs && data.attrs.slot) {
-      delete data.attrs.slot
-    }
-    // named slots should only be respected if the vnode was rendered in the
-    // same context.
-    if ((child.context === context || child.fnContext === context) &&
-      data && data.slot != null
-    ) {
-      const name = data.slot
-      const slot = (slots[name] || (slots[name] = []))
-      if (child.tag === 'template') {
-        slot.push.apply(slot, child.children || [])
-      } else {
-        slot.push(child)
-      }
-    } else {
-      (slots.default || (slots.default = [])).push(child)
-    }
-  }
-  // ignore slots that contains only whitespace
-  for (const name in slots) {
-    if (slots[name].every(isWhitespace)) {
-      delete slots[name]
-    }
-  }
-  return slots
-}
-
-function isWhitespace (node: VNode): boolean {
-  return (node.isComment && !node.asyncFactory) || node.text === ' '
-}
diff --git a/1.Vue/src/core/instance/render.js b/1.Vue/src/core/instance/render.js
deleted file mode 100644
index c888e39..0000000
--- a/1.Vue/src/core/instance/render.js
+++ /dev/null
@@ -1,129 +0,0 @@
-/* @flow */
-
-import {
-  warn,
-  nextTick,
-  emptyObject,
-  handleError,
-  defineReactive
-} from '../util/index'
-
-import { createElement } from '../vdom/create-element'
-import { installRenderHelpers } from './render-helpers/index'
-import { resolveSlots } from './render-helpers/resolve-slots'
-import { normalizeScopedSlots } from '../vdom/helpers/normalize-scoped-slots'
-import VNode, { createEmptyVNode } from '../vdom/vnode'
-
-import { isUpdatingChildComponent } from './lifecycle'
-
-export function initRender (vm: Component) {
-  vm._vnode = null // the root of the child tree
-  vm._staticTrees = null // v-once cached trees
-  const options = vm.$options
-  const parentVnode = vm.$vnode = options._parentVnode // the placeholder node in parent tree
-  const renderContext = parentVnode && parentVnode.context
-  vm.$slots = resolveSlots(options._renderChildren, renderContext)
-  vm.$scopedSlots = emptyObject
-  // bind the createElement fn to this instance
-  // so that we get proper render context inside it.
-  // args order: tag, data, children, normalizationType, alwaysNormalize
-  // internal version is used by render functions compiled from templates
-  vm._c = (a, b, c, d) => createElement(vm, a, b, c, d, false)
-  // normalization is always applied for the public version, used in
-  // user-written render functions.
-  vm.$createElement = (a, b, c, d) => createElement(vm, a, b, c, d, true)
-
-  // $attrs & $listeners are exposed for easier HOC creation.
-  // they need to be reactive so that HOCs using them are always updated
-  const parentData = parentVnode && parentVnode.data
-
-  /* istanbul ignore else */
-  if (process.env.NODE_ENV !== 'production') {
-    defineReactive(vm, '$attrs', parentData && parentData.attrs || emptyObject, () => {
-      !isUpdatingChildComponent && warn(`$attrs is readonly.`, vm)
-    }, true)
-    defineReactive(vm, '$listeners', options._parentListeners || emptyObject, () => {
-      !isUpdatingChildComponent && warn(`$listeners is readonly.`, vm)
-    }, true)
-  } else {
-    defineReactive(vm, '$attrs', parentData && parentData.attrs || emptyObject, null, true)
-    defineReactive(vm, '$listeners', options._parentListeners || emptyObject, null, true)
-  }
-}
-
-export let currentRenderingInstance: Component | null = null
-
-// for testing only
-export function setCurrentRenderingInstance (vm: Component) {
-  currentRenderingInstance = vm
-}
-
-export function renderMixin (Vue: Class<Component>) {
-  // install runtime convenience helpers
-  installRenderHelpers(Vue.prototype)
-
-  Vue.prototype.$nextTick = function (fn: Function) {
-    return nextTick(fn, this)
-  }
-
-  Vue.prototype._render = function (): VNode {
-    const vm: Component = this
-    const { render, _parentVnode } = vm.$options
-
-    if (_parentVnode) {
-      vm.$scopedSlots = normalizeScopedSlots(
-        _parentVnode.data.scopedSlots,
-        vm.$slots,
-        vm.$scopedSlots
-      )
-    }
-
-    // set parent vnode. this allows render functions to have access
-    // to the data on the placeholder node.
-    vm.$vnode = _parentVnode
-    // render self
-    let vnode
-    try {
-      // There's no need to maintain a stack becaues all render fns are called
-      // separately from one another. Nested component's render fns are called
-      // when parent component is patched.
-      currentRenderingInstance = vm
-      vnode = render.call(vm._renderProxy, vm.$createElement)
-    } catch (e) {
-      handleError(e, vm, `render`)
-      // return error render result,
-      // or previous vnode to prevent render error causing blank component
-      /* istanbul ignore else */
-      if (process.env.NODE_ENV !== 'production' && vm.$options.renderError) {
-        try {
-          vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e)
-        } catch (e) {
-          handleError(e, vm, `renderError`)
-          vnode = vm._vnode
-        }
-      } else {
-        vnode = vm._vnode
-      }
-    } finally {
-      currentRenderingInstance = null
-    }
-    // if the returned array contains only a single node, allow it
-    if (Array.isArray(vnode) && vnode.length === 1) {
-      vnode = vnode[0]
-    }
-    // return empty vnode in case the render function errored out
-    if (!(vnode instanceof VNode)) {
-      if (process.env.NODE_ENV !== 'production' && Array.isArray(vnode)) {
-        warn(
-          'Multiple root nodes returned from render function. Render function ' +
-          'should return a single root node.',
-          vm
-        )
-      }
-      vnode = createEmptyVNode()
-    }
-    // set parent
-    vnode.parent = _parentVnode
-    return vnode
-  }
-}
diff --git a/1.Vue/src/core/instance/state.js b/1.Vue/src/core/instance/state.js
deleted file mode 100644
index cc1401a..0000000
--- a/1.Vue/src/core/instance/state.js
+++ /dev/null
@@ -1,368 +0,0 @@
-/* @flow */
-
-import config from '../config'
-import Watcher from '../observer/watcher'
-import Dep, { pushTarget, popTarget } from '../observer/dep'
-import { isUpdatingChildComponent } from './lifecycle'
-
-import {
-  set,
-  del,
-  observe,
-  defineReactive,
-  toggleObserving
-} from '../observer/index'
-
-import {
-  warn,
-  bind,
-  noop,
-  hasOwn,
-  hyphenate,
-  isReserved,
-  handleError,
-  nativeWatch,
-  validateProp,
-  isPlainObject,
-  isServerRendering,
-  isReservedAttribute
-} from '../util/index'
-
-const sharedPropertyDefinition = {
-  enumerable: true,
-  configurable: true,
-  get: noop,
-  set: noop
-}
-
-export function proxy (target: Object, sourceKey: string, key: string) {
-  sharedPropertyDefinition.get = function proxyGetter () {
-    return this[sourceKey][key]
-  }
-  sharedPropertyDefinition.set = function proxySetter (val) {
-    this[sourceKey][key] = val
-  }
-  Object.defineProperty(target, key, sharedPropertyDefinition)
-}
-
-export function initState (vm: Component) {
-  vm._watchers = []
-  const opts = vm.$options
-  if (opts.props) initProps(vm, opts.props)
-  if (opts.methods) initMethods(vm, opts.methods)
-  if (opts.data) {
-    initData(vm)
-  } else {
-    observe(vm._data = {}, true /* asRootData */)
-  }
-  if (opts.computed) initComputed(vm, opts.computed)
-  if (opts.watch && opts.watch !== nativeWatch) {
-    initWatch(vm, opts.watch)
-  }
-}
-
-function initProps (vm: Component, propsOptions: Object) {
-  const propsData = vm.$options.propsData || {}
-  const props = vm._props = {}
-  // cache prop keys so that future props updates can iterate using Array
-  // instead of dynamic object key enumeration.
-  const keys = vm.$options._propKeys = []
-  const isRoot = !vm.$parent
-  // root instance props should be converted
-  if (!isRoot) {
-    toggleObserving(false)
-  }
-  for (const key in propsOptions) {
-    keys.push(key)
-    const value = validateProp(key, propsOptions, propsData, vm)
-    /* istanbul ignore else */
-    if (process.env.NODE_ENV !== 'production') {
-      const hyphenatedKey = hyphenate(key)
-      if (isReservedAttribute(hyphenatedKey) ||
-          config.isReservedAttr(hyphenatedKey)) {
-        warn(
-          `"${hyphenatedKey}" is a reserved attribute and cannot be used as component prop.`,
-          vm
-        )
-      }
-      defineReactive(props, key, value, () => {
-        if (!isRoot && !isUpdatingChildComponent) {
-          warn(
-            `Avoid mutating a prop directly since the value will be ` +
-            `overwritten whenever the parent component re-renders. ` +
-            `Instead, use a data or computed property based on the prop's ` +
-            `value. Prop being mutated: "${key}"`,
-            vm
-          )
-        }
-      })
-    } else {
-      defineReactive(props, key, value)
-    }
-    // static props are already proxied on the component's prototype
-    // during Vue.extend(). We only need to proxy props defined at
-    // instantiation here.
-    if (!(key in vm)) {
-      proxy(vm, `_props`, key)
-    }
-  }
-  toggleObserving(true)
-}
-
-function initData (vm: Component) {
-  let data = vm.$options.data
-  data = vm._data = typeof data === 'function'
-    ? getData(data, vm)
-    : data || {}
-  if (!isPlainObject(data)) {
-    data = {}
-    process.env.NODE_ENV !== 'production' && warn(
-      'data functions should return an object:\n' +
-      'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function',
-      vm
-    )
-  }
-  // proxy data on instance
-  const keys = Object.keys(data)
-  const props = vm.$options.props
-  const methods = vm.$options.methods
-  let i = keys.length
-  while (i--) {
-    const key = keys[i]
-    if (process.env.NODE_ENV !== 'production') {
-      if (methods && hasOwn(methods, key)) {
-        warn(
-          `Method "${key}" has already been defined as a data property.`,
-          vm
-        )
-      }
-    }
-    if (props && hasOwn(props, key)) {
-      process.env.NODE_ENV !== 'production' && warn(
-        `The data property "${key}" is already declared as a prop. ` +
-        `Use prop default value instead.`,
-        vm
-      )
-    } else if (!isReserved(key)) {
-      proxy(vm, `_data`, key)
-    }
-  }
-  // observe data
-  observe(data, true /* asRootData */)
-}
-
-export function getData (data: Function, vm: Component): any {
-  // #7573 disable dep collection when invoking data getters
-  pushTarget()
-  try {
-    return data.call(vm, vm)
-  } catch (e) {
-    handleError(e, vm, `data()`)
-    return {}
-  } finally {
-    popTarget()
-  }
-}
-
-const computedWatcherOptions = { lazy: true }
-
-function initComputed (vm: Component, computed: Object) {
-  // $flow-disable-line
-  const watchers = vm._computedWatchers = Object.create(null)
-  // computed properties are just getters during SSR
-  const isSSR = isServerRendering()
-
-  for (const key in computed) {
-    const userDef = computed[key]
-    const getter = typeof userDef === 'function' ? userDef : userDef.get
-    if (process.env.NODE_ENV !== 'production' && getter == null) {
-      warn(
-        `Getter is missing for computed property "${key}".`,
-        vm
-      )
-    }
-
-    if (!isSSR) {
-      // create internal watcher for the computed property.
-      watchers[key] = new Watcher(
-        vm,
-        getter || noop,
-        noop,
-        computedWatcherOptions
-      )
-    }
-
-    // component-defined computed properties are already defined on the
-    // component prototype. We only need to define computed properties defined
-    // at instantiation here.
-    if (!(key in vm)) {
-      defineComputed(vm, key, userDef)
-    } else if (process.env.NODE_ENV !== 'production') {
-      if (key in vm.$data) {
-        warn(`The computed property "${key}" is already defined in data.`, vm)
-      } else if (vm.$options.props && key in vm.$options.props) {
-        warn(`The computed property "${key}" is already defined as a prop.`, vm)
-      }
-    }
-  }
-}
-
-export function defineComputed (
-  target: any,
-  key: string,
-  userDef: Object | Function
-) {
-  const shouldCache = !isServerRendering()
-  if (typeof userDef === 'function') {
-    sharedPropertyDefinition.get = shouldCache
-      ? createComputedGetter(key)
-      : createGetterInvoker(userDef)
-    sharedPropertyDefinition.set = noop
-  } else {
-    sharedPropertyDefinition.get = userDef.get
-      ? shouldCache && userDef.cache !== false
-        ? createComputedGetter(key)
-        : createGetterInvoker(userDef.get)
-      : noop
-    sharedPropertyDefinition.set = userDef.set || noop
-  }
-  if (process.env.NODE_ENV !== 'production' &&
-      sharedPropertyDefinition.set === noop) {
-    sharedPropertyDefinition.set = function () {
-      warn(
-        `Computed property "${key}" was assigned to but it has no setter.`,
-        this
-      )
-    }
-  }
-  Object.defineProperty(target, key, sharedPropertyDefinition)
-}
-
-function createComputedGetter (key) {
-  return function computedGetter () {
-    const watcher = this._computedWatchers && this._computedWatchers[key]
-    if (watcher) {
-      if (watcher.dirty) {
-        watcher.evaluate()
-      }
-      if (Dep.target) {
-        watcher.depend()
-      }
-      return watcher.value
-    }
-  }
-}
-
-function createGetterInvoker(fn) {
-  return function computedGetter () {
-    return fn.call(this, this)
-  }
-}
-
-function initMethods (vm: Component, methods: Object) {
-  const props = vm.$options.props
-  for (const key in methods) {
-    if (process.env.NODE_ENV !== 'production') {
-      if (typeof methods[key] !== 'function') {
-        warn(
-          `Method "${key}" has type "${typeof methods[key]}" in the component definition. ` +
-          `Did you reference the function correctly?`,
-          vm
-        )
-      }
-      if (props && hasOwn(props, key)) {
-        warn(
-          `Method "${key}" has already been defined as a prop.`,
-          vm
-        )
-      }
-      if ((key in vm) && isReserved(key)) {
-        warn(
-          `Method "${key}" conflicts with an existing Vue instance method. ` +
-          `Avoid defining component methods that start with _ or $.`
-        )
-      }
-    }
-    vm[key] = typeof methods[key] !== 'function' ? noop : bind(methods[key], vm)
-  }
-}
-
-function initWatch (vm: Component, watch: Object) {
-  for (const key in watch) {
-    const handler = watch[key]
-    if (Array.isArray(handler)) {
-      for (let i = 0; i < handler.length; i++) {
-        createWatcher(vm, key, handler[i])
-      }
-    } else {
-      createWatcher(vm, key, handler)
-    }
-  }
-}
-
-function createWatcher (
-  vm: Component,
-  expOrFn: string | Function,
-  handler: any,
-  options?: Object
-) {
-  if (isPlainObject(handler)) {
-    options = handler
-    handler = handler.handler
-  }
-  if (typeof handler === 'string') {
-    handler = vm[handler]
-  }
-  return vm.$watch(expOrFn, handler, options)
-}
-
-export function stateMixin (Vue: Class<Component>) {
-  // flow somehow has problems with directly declared definition object
-  // when using Object.defineProperty, so we have to procedurally build up
-  // the object here.
-  const dataDef = {}
-  dataDef.get = function () { return this._data }
-  const propsDef = {}
-  propsDef.get = function () { return this._props }
-  if (process.env.NODE_ENV !== 'production') {
-    dataDef.set = function () {
-      warn(
-        'Avoid replacing instance root $data. ' +
-        'Use nested data properties instead.',
-        this
-      )
-    }
-    propsDef.set = function () {
-      warn(`$props is readonly.`, this)
-    }
-  }
-  Object.defineProperty(Vue.prototype, '$data', dataDef)
-  Object.defineProperty(Vue.prototype, '$props', propsDef)
-
-  Vue.prototype.$set = set
-  Vue.prototype.$delete = del
-
-  Vue.prototype.$watch = function (
-    expOrFn: string | Function,
-    cb: any,
-    options?: Object
-  ): Function {
-    const vm: Component = this
-    if (isPlainObject(cb)) {
-      return createWatcher(vm, expOrFn, cb, options)
-    }
-    options = options || {}
-    options.user = true
-    const watcher = new Watcher(vm, expOrFn, cb, options)
-    if (options.immediate) {
-      try {
-        cb.call(vm, watcher.value)
-      } catch (error) {
-        handleError(error, vm, `callback for immediate watcher "${watcher.expression}"`)
-      }
-    }
-    return function unwatchFn () {
-      watcher.teardown()
-    }
-  }
-}
diff --git a/1.Vue/src/core/observer/array.js b/1.Vue/src/core/observer/array.js
deleted file mode 100644
index 684e37e..0000000
--- a/1.Vue/src/core/observer/array.js
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- * not type checking this file because flow doesn't play well with
- * dynamically accessing methods on Array prototype
- */
-
-import { def } from '../util/index'
-
-const arrayProto = Array.prototype
-export const arrayMethods = Object.create(arrayProto)
-
-const methodsToPatch = [
-  'push',
-  'pop',
-  'shift',
-  'unshift',
-  'splice',
-  'sort',
-  'reverse'
-]
-
-/**
- * Intercept mutating methods and emit events
- */
-methodsToPatch.forEach(function (method) {
-  // cache original method
-  const original = arrayProto[method]
-  def(arrayMethods, method, function mutator (...args) {
-    const result = original.apply(this, args)
-    const ob = this.__ob__
-    let 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
-  })
-})
diff --git a/1.Vue/src/core/observer/dep.js b/1.Vue/src/core/observer/dep.js
deleted file mode 100644
index 974b954..0000000
--- a/1.Vue/src/core/observer/dep.js
+++ /dev/null
@@ -1,66 +0,0 @@
-/* @flow */
-
-import type Watcher from './watcher'
-import { remove } from '../util/index'
-import config from '../config'
-
-let uid = 0
-
-/**
- * A dep is an observable that can have multiple
- * directives subscribing to it.
- */
-export default class Dep {
-  static target: ?Watcher;
-  id: number;
-  subs: Array<Watcher>;
-
-  constructor () {
-    this.id = uid++
-    this.subs = []
-  }
-
-  addSub (sub: Watcher) {
-    this.subs.push(sub)
-  }
-
-  removeSub (sub: Watcher) {
-    remove(this.subs, sub)
-  }
-
-  depend () {
-    if (Dep.target) {
-      Dep.target.addDep(this)
-    }
-  }
-
-  notify () {
-    // stabilize the subscriber list first
-    const subs = this.subs.slice()
-    if (process.env.NODE_ENV !== 'production' && !config.async) {
-      // subs aren't sorted in scheduler if not running async
-      // we need to sort them now to make sure they fire in correct
-      // order
-      subs.sort((a, b) => a.id - b.id)
-    }
-    for (let i = 0, l = subs.length; i < l; i++) {
-      subs[i].update()
-    }
-  }
-}
-
-// The current target watcher being evaluated.
-// This is globally unique because only one watcher
-// can be evaluated at a time.
-Dep.target = null
-const targetStack = []
-
-export function pushTarget (target: ?Watcher) {
-  targetStack.push(target)
-  Dep.target = target
-}
-
-export function popTarget () {
-  targetStack.pop()
-  Dep.target = targetStack[targetStack.length - 1]
-}
diff --git a/1.Vue/src/core/observer/index.js b/1.Vue/src/core/observer/index.js
deleted file mode 100644
index 545adb6..0000000
--- a/1.Vue/src/core/observer/index.js
+++ /dev/null
@@ -1,276 +0,0 @@
-/* @flow */
-
-import Dep from './dep'
-import VNode from '../vdom/vnode'
-import { arrayMethods } from './array'
-import {
-  def,
-  warn,
-  hasOwn,
-  hasProto,
-  isObject,
-  isPlainObject,
-  isPrimitive,
-  isUndef,
-  isValidArrayIndex,
-  isServerRendering
-} from '../util/index'
-
-const arrayKeys = Object.getOwnPropertyNames(arrayMethods)
-
-/**
- * In some cases we may want to disable observation inside a component's
- * update computation.
- */
-export let shouldObserve: boolean = true
-
-export function toggleObserving (value: boolean) {
-  shouldObserve = value
-}
-
-/**
- * Observer class that is attached to each observed
- * object. Once attached, the observer converts the target
- * object's property keys into getter/setters that
- * collect dependencies and dispatch updates.
- */
-export class Observer {
-  value: any;
-  dep: Dep;
-  vmCount: number; // number of vms that have this object as root $data
-
-  constructor (value: any) {
-    this.value = value
-    this.dep = new Dep()
-    this.vmCount = 0
-    def(value, '__ob__', this)
-    if (Array.isArray(value)) {
-      if (hasProto) {
-        protoAugment(value, arrayMethods)
-      } else {
-        copyAugment(value, arrayMethods, arrayKeys)
-      }
-      this.observeArray(value)
-    } else {
-      this.walk(value)
-    }
-  }
-
-  /**
-   * Walk through all properties and convert them into
-   * getter/setters. This method should only be called when
-   * value type is Object.
-   */
-  walk (obj: Object) {
-    const keys = Object.keys(obj)
-    for (let i = 0; i < keys.length; i++) {
-      defineReactive(obj, keys[i])
-    }
-  }
-
-  /**
-   * Observe a list of Array items.
-   */
-  observeArray (items: Array<any>) {
-    for (let i = 0, l = items.length; i < l; i++) {
-      observe(items[i])
-    }
-  }
-}
-
-// helpers
-
-/**
- * Augment a target Object or Array by intercepting
- * the prototype chain using __proto__
- */
-function protoAugment (target, src: Object) {
-  /* eslint-disable no-proto */
-  target.__proto__ = src
-  /* eslint-enable no-proto */
-}
-
-/**
- * Augment a target Object or Array by defining
- * hidden properties.
- */
-/* istanbul ignore next */
-function copyAugment (target: Object, src: Object, keys: Array<string>) {
-  for (let i = 0, l = keys.length; i < l; i++) {
-    const 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.
- */
-export function observe (value: any, asRootData: ?boolean): Observer | void {
-  if (!isObject(value) || value instanceof VNode) {
-    return
-  }
-  let ob: Observer | void
-  if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
-    ob = value.__ob__
-  } else if (
-    shouldObserve &&
-    !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.
- */
-export function defineReactive (
-  obj: Object,
-  key: string,
-  val: any,
-  customSetter?: ?Function,
-  shallow?: boolean
-) {
-  const dep = new Dep()
-
-  const property = Object.getOwnPropertyDescriptor(obj, key)
-  if (property && property.configurable === false) {
-    return
-  }
-
-  // cater for pre-defined getter/setters
-  const getter = property && property.get
-  const setter = property && property.set
-  if ((!getter || setter) && arguments.length === 2) {
-    val = obj[key]
-  }
-
-  let childOb = !shallow && observe(val)
-  Object.defineProperty(obj, key, {
-    enumerable: true,
-    configurable: true,
-    get: function reactiveGetter () {
-      const 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) {
-      const 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 (process.env.NODE_ENV !== 'production' && customSetter) {
-        customSetter()
-      }
-      // #7981: for accessor properties without setter
-      if (getter && !setter) return
-      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.
- */
-export function set (target: Array<any> | Object, key: any, val: any): any {
-  if (process.env.NODE_ENV !== 'production' &&
-    (isUndef(target) || isPrimitive(target))
-  ) {
-    warn(`Cannot set reactive property on undefined, null, or primitive value: ${(target: any)}`)
-  }
-  if (Array.isArray(target) && isValidArrayIndex(key)) {
-    target.length = Math.max(target.length, key)
-    target.splice(key, 1, val)
-    return val
-  }
-  if (key in target && !(key in Object.prototype)) {
-    target[key] = val
-    return val
-  }
-  const ob = (target: any).__ob__
-  if (target._isVue || (ob && ob.vmCount)) {
-    process.env.NODE_ENV !== '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(ob.value, key, val)
-  ob.dep.notify()
-  return val
-}
-
-/**
- * Delete a property and trigger change if necessary.
- */
-export function del (target: Array<any> | Object, key: any) {
-  if (process.env.NODE_ENV !== 'production' &&
-    (isUndef(target) || isPrimitive(target))
-  ) {
-    warn(`Cannot delete reactive property on undefined, null, or primitive value: ${(target: any)}`)
-  }
-  if (Array.isArray(target) && isValidArrayIndex(key)) {
-    target.splice(key, 1)
-    return
-  }
-  const ob = (target: any).__ob__
-  if (target._isVue || (ob && ob.vmCount)) {
-    process.env.NODE_ENV !== '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: Array<any>) {
-  for (let e, i = 0, l = value.length; i < l; i++) {
-    e = value[i]
-    e && e.__ob__ && e.__ob__.dep.depend()
-    if (Array.isArray(e)) {
-      dependArray(e)
-    }
-  }
-}
diff --git a/1.Vue/src/core/observer/scheduler.js b/1.Vue/src/core/observer/scheduler.js
deleted file mode 100644
index ed5c504..0000000
--- a/1.Vue/src/core/observer/scheduler.js
+++ /dev/null
@@ -1,190 +0,0 @@
-/* @flow */
-
-import type Watcher from './watcher'
-import config from '../config'
-import { callHook, activateChildComponent } from '../instance/lifecycle'
-
-import {
-  warn,
-  nextTick,
-  devtools,
-  inBrowser,
-  isIE
-} from '../util/index'
-
-export const MAX_UPDATE_COUNT = 100
-
-const queue: Array<Watcher> = []
-const activatedChildren: Array<Component> = []
-let has: { [key: number]: ?true } = {}
-let circular: { [key: number]: number } = {}
-let waiting = false
-let flushing = false
-let index = 0
-
-/**
- * Reset the scheduler's state.
- */
-function resetSchedulerState () {
-  index = queue.length = activatedChildren.length = 0
-  has = {}
-  if (process.env.NODE_ENV !== 'production') {
-    circular = {}
-  }
-  waiting = flushing = false
-}
-
-// Async edge case #6566 requires saving the timestamp when event listeners are
-// attached. However, calling performance.now() has a perf overhead especially
-// if the page has thousands of event listeners. Instead, we take a timestamp
-// every time the scheduler flushes and use that for all event listeners
-// attached during that flush.
-export let currentFlushTimestamp = 0
-
-// Async edge case fix requires storing an event listener's attach timestamp.
-let getNow: () => number = Date.now
-
-// Determine what event timestamp the browser is using. Annoyingly, the
-// timestamp can either be hi-res (relative to page load) or low-res
-// (relative to UNIX epoch), so in order to compare time we have to use the
-// same timestamp type when saving the flush timestamp.
-// All IE versions use low-res event timestamps, and have problematic clock
-// implementations (#9632)
-if (inBrowser && !isIE) {
-  const performance = window.performance
-  if (
-    performance &&
-    typeof performance.now === 'function' &&
-    getNow() > document.createEvent('Event').timeStamp
-  ) {
-    // if the event timestamp, although evaluated AFTER the Date.now(), is
-    // smaller than it, it means the event is using a hi-res timestamp,
-    // and we need to use the hi-res version for event listener timestamps as
-    // well.
-    getNow = () => performance.now()
-  }
-}
-
-/**
- * Flush both queues and run the watchers.
- */
-function flushSchedulerQueue () {
-  currentFlushTimestamp = getNow()
-  flushing = true
-  let watcher, id
-
-  // Sort queue before flush.
-  // This ensures that:
-  // 1. Components are updated from parent to child. (because parent is always
-  //    created before the child)
-  // 2. A component's user watchers are run before its render watcher (because
-  //    user watchers are created before the render watcher)
-  // 3. If a component is destroyed during a parent component's watcher run,
-  //    its watchers can be skipped.
-  queue.sort((a, b) => a.id - b.id)
-
-  // do not cache length because more watchers might be pushed
-  // as we run existing watchers
-  for (index = 0; index < queue.length; index++) {
-    watcher = queue[index]
-    if (watcher.before) {
-      watcher.before()
-    }
-    id = watcher.id
-    has[id] = null
-    watcher.run()
-    // in dev build, check and stop circular updates.
-    if (process.env.NODE_ENV !== 'production' && has[id] != null) {
-      circular[id] = (circular[id] || 0) + 1
-      if (circular[id] > MAX_UPDATE_COUNT) {
-        warn(
-          'You may have an infinite update loop ' + (
-            watcher.user
-              ? `in watcher with expression "${watcher.expression}"`
-              : `in a component render function.`
-          ),
-          watcher.vm
-        )
-        break
-      }
-    }
-  }
-
-  // keep copies of post queues before resetting state
-  const activatedQueue = activatedChildren.slice()
-  const updatedQueue = queue.slice()
-
-  resetSchedulerState()
-
-  // call component updated and activated hooks
-  callActivatedHooks(activatedQueue)
-  callUpdatedHooks(updatedQueue)
-
-  // devtool hook
-  /* istanbul ignore if */
-  if (devtools && config.devtools) {
-    devtools.emit('flush')
-  }
-}
-
-function callUpdatedHooks (queue) {
-  let i = queue.length
-  while (i--) {
-    const watcher = queue[i]
-    const vm = watcher.vm
-    if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {
-      callHook(vm, 'updated')
-    }
-  }
-}
-
-/**
- * Queue a kept-alive component that was activated during patch.
- * The queue will be processed after the entire tree has been patched.
- */
-export function queueActivatedComponent (vm: Component) {
-  // setting _inactive to false here so that a render function can
-  // rely on checking whether it's in an inactive tree (e.g. router-view)
-  vm._inactive = false
-  activatedChildren.push(vm)
-}
-
-function callActivatedHooks (queue) {
-  for (let i = 0; i < queue.length; i++) {
-    queue[i]._inactive = true
-    activateChildComponent(queue[i], true /* true */)
-  }
-}
-
-/**
- * Push a watcher into the watcher queue.
- * Jobs with duplicate IDs will be skipped unless it's
- * pushed when the queue is being flushed.
- */
-export function queueWatcher (watcher: Watcher) {
-  const id = watcher.id
-  if (has[id] == null) {
-    has[id] = true
-    if (!flushing) {
-      queue.push(watcher)
-    } else {
-      // if already flushing, splice the watcher based on its id
-      // if already past its id, it will be run next immediately.
-      let i = queue.length - 1
-      while (i > index && queue[i].id > watcher.id) {
-        i--
-      }
-      queue.splice(i + 1, 0, watcher)
-    }
-    // queue the flush
-    if (!waiting) {
-      waiting = true
-
-      if (process.env.NODE_ENV !== 'production' && !config.async) {
-        flushSchedulerQueue()
-        return
-      }
-      nextTick(flushSchedulerQueue)
-    }
-  }
-}
diff --git a/1.Vue/src/core/observer/traverse.js b/1.Vue/src/core/observer/traverse.js
deleted file mode 100644
index 6b26524..0000000
--- a/1.Vue/src/core/observer/traverse.js
+++ /dev/null
@@ -1,40 +0,0 @@
-/* @flow */
-
-import { _Set as Set, isObject } from '../util/index'
-import type { SimpleSet } from '../util/index'
-import VNode from '../vdom/vnode'
-
-const seenObjects = new Set()
-
-/**
- * Recursively traverse an object to evoke all converted
- * getters, so that every nested property inside the object
- * is collected as a "deep" dependency.
- */
-export function traverse (val: any) {
-  _traverse(val, seenObjects)
-  seenObjects.clear()
-}
-
-function _traverse (val: any, seen: SimpleSet) {
-  let i, keys
-  const isA = Array.isArray(val)
-  if ((!isA && !isObject(val)) || Object.isFrozen(val) || val instanceof VNode) {
-    return
-  }
-  if (val.__ob__) {
-    const depId = val.__ob__.dep.id
-    if (seen.has(depId)) {
-      return
-    }
-    seen.add(depId)
-  }
-  if (isA) {
-    i = val.length
-    while (i--) _traverse(val[i], seen)
-  } else {
-    keys = Object.keys(val)
-    i = keys.length
-    while (i--) _traverse(val[keys[i]], seen)
-  }
-}
diff --git a/1.Vue/src/core/observer/watcher.js b/1.Vue/src/core/observer/watcher.js
deleted file mode 100644
index 5fbcdf3..0000000
--- a/1.Vue/src/core/observer/watcher.js
+++ /dev/null
@@ -1,243 +0,0 @@
-/* @flow */
-
-import {
-  warn,
-  remove,
-  isObject,
-  parsePath,
-  _Set as Set,
-  handleError,
-  noop
-} from '../util/index'
-
-import { traverse } from './traverse'
-import { queueWatcher } from './scheduler'
-import Dep, { pushTarget, popTarget } from './dep'
-
-import type { SimpleSet } from '../util/index'
-
-let uid = 0
-
-/**
- * A watcher parses an expression, collects dependencies,
- * and fires callback when the expression value changes.
- * This is used for both the $watch() api and directives.
- */
-export default class Watcher {
-  vm: Component;
-  expression: string;
-  cb: Function;
-  id: number;
-  deep: boolean;
-  user: boolean;
-  lazy: boolean;
-  sync: boolean;
-  dirty: boolean;
-  active: boolean;
-  deps: Array<Dep>;
-  newDeps: Array<Dep>;
-  depIds: SimpleSet;
-  newDepIds: SimpleSet;
-  before: ?Function;
-  getter: Function;
-  value: any;
-
-  constructor (
-    vm: Component,
-    expOrFn: string | Function,
-    cb: Function,
-    options?: ?Object,
-    isRenderWatcher?: boolean
-  ) {
-    this.vm = vm
-    if (isRenderWatcher) {
-      vm._watcher = this
-    }
-    vm._watchers.push(this)
-    // options
-    if (options) {
-      this.deep = !!options.deep
-      this.user = !!options.user
-      this.lazy = !!options.lazy
-      this.sync = !!options.sync
-      this.before = options.before
-    } else {
-      this.deep = this.user = this.lazy = this.sync = false
-    }
-    this.cb = cb
-    this.id = ++uid // uid for batching
-    this.active = true
-    this.dirty = this.lazy // for lazy watchers
-    this.deps = []
-    this.newDeps = []
-    this.depIds = new Set()
-    this.newDepIds = new Set()
-    this.expression = process.env.NODE_ENV !== 'production'
-      ? expOrFn.toString()
-      : ''
-    // parse expression for getter
-    if (typeof expOrFn === 'function') {
-      this.getter = expOrFn
-    } else {
-      this.getter = parsePath(expOrFn)
-      if (!this.getter) {
-        this.getter = noop
-        process.env.NODE_ENV !== 'production' && warn(
-          `Failed watching path: "${expOrFn}" ` +
-          'Watcher only accepts simple dot-delimited paths. ' +
-          'For full control, use a function instead.',
-          vm
-        )
-      }
-    }
-    this.value = this.lazy
-      ? undefined
-      : this.get()
-  }
-
-  /**
-   * Evaluate the getter, and re-collect dependencies.
-   */
-  get () {
-    pushTarget(this)
-    let value
-    const vm = this.vm
-    try {
-      value = this.getter.call(vm, vm)
-    } catch (e) {
-      if (this.user) {
-        handleError(e, vm, `getter for watcher "${this.expression}"`)
-      } else {
-        throw e
-      }
-    } finally {
-      // "touch" every property so they are all tracked as
-      // dependencies for deep watching
-      if (this.deep) {
-        traverse(value)
-      }
-      popTarget()
-      this.cleanupDeps()
-    }
-    return value
-  }
-
-  /**
-   * Add a dependency to this directive.
-   */
-  addDep (dep: Dep) {
-    const id = dep.id
-    if (!this.newDepIds.has(id)) {
-      this.newDepIds.add(id)
-      this.newDeps.push(dep)
-      if (!this.depIds.has(id)) {
-        dep.addSub(this)
-      }
-    }
-  }
-
-  /**
-   * Clean up for dependency collection.
-   */
-  cleanupDeps () {
-    let i = this.deps.length
-    while (i--) {
-      const dep = this.deps[i]
-      if (!this.newDepIds.has(dep.id)) {
-        dep.removeSub(this)
-      }
-    }
-    let tmp = this.depIds
-    this.depIds = this.newDepIds
-    this.newDepIds = tmp
-    this.newDepIds.clear()
-    tmp = this.deps
-    this.deps = this.newDeps
-    this.newDeps = tmp
-    this.newDeps.length = 0
-  }
-
-  /**
-   * Subscriber interface.
-   * Will be called when a dependency changes.
-   */
-  update () {
-    /* istanbul ignore else */
-    if (this.lazy) {
-      this.dirty = true
-    } else if (this.sync) {
-      this.run()
-    } else {
-      queueWatcher(this)
-    }
-  }
-
-  /**
-   * Scheduler job interface.
-   * Will be called by the scheduler.
-   */
-  run () {
-    if (this.active) {
-      const value = this.get()
-      if (
-        value !== this.value ||
-        // Deep watchers and watchers on Object/Arrays should fire even
-        // when the value is the same, because the value may
-        // have mutated.
-        isObject(value) ||
-        this.deep
-      ) {
-        // set new value
-        const oldValue = this.value
-        this.value = value
-        if (this.user) {
-          try {
-            this.cb.call(this.vm, value, oldValue)
-          } catch (e) {
-            handleError(e, this.vm, `callback for watcher "${this.expression}"`)
-          }
-        } else {
-          this.cb.call(this.vm, value, oldValue)
-        }
-      }
-    }
-  }
-
-  /**
-   * Evaluate the value of the watcher.
-   * This only gets called for lazy watchers.
-   */
-  evaluate () {
-    this.value = this.get()
-    this.dirty = false
-  }
-
-  /**
-   * Depend on all deps collected by this watcher.
-   */
-  depend () {
-    let i = this.deps.length
-    while (i--) {
-      this.deps[i].depend()
-    }
-  }
-
-  /**
-   * Remove self from all dependencies' subscriber list.
-   */
-  teardown () {
-    if (this.active) {
-      // remove self from vm's watcher list
-      // this is a somewhat expensive operation so we skip it
-      // if the vm is being destroyed.
-      if (!this.vm._isBeingDestroyed) {
-        remove(this.vm._watchers, this)
-      }
-      let i = this.deps.length
-      while (i--) {
-        this.deps[i].removeSub(this)
-      }
-      this.active = false
-    }
-  }
-}
diff --git a/1.Vue/src/core/util/debug.js b/1.Vue/src/core/util/debug.js
deleted file mode 100644
index 4aef7b5..0000000
--- a/1.Vue/src/core/util/debug.js
+++ /dev/null
@@ -1,100 +0,0 @@
-/* @flow */
-
-import config from '../config'
-import { noop } from 'shared/util'
-
-export let warn = noop
-export let tip = noop
-export let generateComponentTrace = (noop: any) // work around flow check
-export let formatComponentName = (noop: any)
-
-if (process.env.NODE_ENV !== 'production') {
-  const hasConsole = typeof console !== 'undefined'
-  const classifyRE = /(?:^|[-_])(\w)/g
-  const classify = str => str
-    .replace(classifyRE, c => c.toUpperCase())
-    .replace(/[-_]/g, '')
-
-  warn = (msg, vm) => {
-    const trace = vm ? generateComponentTrace(vm) : ''
-
-    if (config.warnHandler) {
-      config.warnHandler.call(null, msg, vm, trace)
-    } else if (hasConsole && (!config.silent)) {
-      console.error(`[Vue warn]: ${msg}${trace}`)
-    }
-  }
-
-  tip = (msg, vm) => {
-    if (hasConsole && (!config.silent)) {
-      console.warn(`[Vue tip]: ${msg}` + (
-        vm ? generateComponentTrace(vm) : ''
-      ))
-    }
-  }
-
-  formatComponentName = (vm, includeFile) => {
-    if (vm.$root === vm) {
-      return '<Root>'
-    }
-    const options = typeof vm === 'function' && vm.cid != null
-      ? vm.options
-      : vm._isVue
-        ? vm.$options || vm.constructor.options
-        : vm
-    let name = options.name || options._componentTag
-    const file = options.__file
-    if (!name && file) {
-      const match = file.match(/([^/\\]+)\.vue$/)
-      name = match && match[1]
-    }
-
-    return (
-      (name ? `<${classify(name)}>` : `<Anonymous>`) +
-      (file && includeFile !== false ? ` at ${file}` : '')
-    )
-  }
-
-  const repeat = (str, n) => {
-    let res = ''
-    while (n) {
-      if (n % 2 === 1) res += str
-      if (n > 1) str += str
-      n >>= 1
-    }
-    return res
-  }
-
-  generateComponentTrace = vm => {
-    if (vm._isVue && vm.$parent) {
-      const tree = []
-      let currentRecursiveSequence = 0
-      while (vm) {
-        if (tree.length > 0) {
-          const last = tree[tree.length - 1]
-          if (last.constructor === vm.constructor) {
-            currentRecursiveSequence++
-            vm = vm.$parent
-            continue
-          } else if (currentRecursiveSequence > 0) {
-            tree[tree.length - 1] = [last, currentRecursiveSequence]
-            currentRecursiveSequence = 0
-          }
-        }
-        tree.push(vm)
-        vm = vm.$parent
-      }
-      return '\n\nfound in\n\n' + tree
-        .map((vm, i) => `${
-          i === 0 ? '---> ' : repeat(' ', 5 + i * 2)
-        }${
-          Array.isArray(vm)
-            ? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)`
-            : formatComponentName(vm)
-        }`)
-        .join('\n')
-    } else {
-      return `\n\n(found in ${formatComponentName(vm)})`
-    }
-  }
-}
diff --git a/1.Vue/src/core/util/env.js b/1.Vue/src/core/util/env.js
deleted file mode 100644
index eff1d21..0000000
--- a/1.Vue/src/core/util/env.js
+++ /dev/null
@@ -1,97 +0,0 @@
-/* @flow */
-
-// can we use __proto__?
-export const hasProto = '__proto__' in {}
-
-// Browser environment sniffing
-export const inBrowser = typeof window !== 'undefined'
-export const inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform
-export const weexPlatform = inWeex && WXEnvironment.platform.toLowerCase()
-export const UA = inBrowser && window.navigator.userAgent.toLowerCase()
-export const isIE = UA && /msie|trident/.test(UA)
-export const isIE9 = UA && UA.indexOf('msie 9.0') > 0
-export const isEdge = UA && UA.indexOf('edge/') > 0
-export const isAndroid = (UA && UA.indexOf('android') > 0) || (weexPlatform === 'android')
-export const isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || (weexPlatform === 'ios')
-export const isChrome = UA && /chrome\/\d+/.test(UA) && !isEdge
-export const isPhantomJS = UA && /phantomjs/.test(UA)
-export const isFF = UA && UA.match(/firefox\/(\d+)/)
-
-// Firefox has a "watch" function on Object.prototype...
-export const nativeWatch = ({}).watch
-
-export let supportsPassive = false
-if (inBrowser) {
-  try {
-    const opts = {}
-    Object.defineProperty(opts, 'passive', ({
-      get () {
-        /* istanbul ignore next */
-        supportsPassive = true
-      }
-    }: Object)) // 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
-let _isServer
-export const isServerRendering = () => {
-  if (_isServer === undefined) {
-    /* istanbul ignore if */
-    if (!inBrowser && !inWeex && typeof global !== 'undefined') {
-      // detect presence of vue-server-renderer and avoid
-      // Webpack shimming the process
-      _isServer = global['process'] && global['process'].env.VUE_ENV === 'server'
-    } else {
-      _isServer = false
-    }
-  }
-  return _isServer
-}
-
-// detect devtools
-export const devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__
-
-/* istanbul ignore next */
-export function isNative (Ctor: any): boolean {
-  return typeof Ctor === 'function' && /native code/.test(Ctor.toString())
-}
-
-export const hasSymbol =
-  typeof Symbol !== 'undefined' && isNative(Symbol) &&
-  typeof Reflect !== 'undefined' && isNative(Reflect.ownKeys)
-
-let _Set
-/* istanbul ignore if */ // $flow-disable-line
-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 = class Set implements SimpleSet {
-    set: Object;
-    constructor () {
-      this.set = Object.create(null)
-    }
-    has (key: string | number) {
-      return this.set[key] === true
-    }
-    add (key: string | number) {
-      this.set[key] = true
-    }
-    clear () {
-      this.set = Object.create(null)
-    }
-  }
-}
-
-interface SimpleSet {
-  has(key: string | number): boolean;
-  add(key: string | number): mixed;
-  clear(): void;
-}
-
-export { _Set }
-export type { SimpleSet }
diff --git a/1.Vue/src/core/util/error.js b/1.Vue/src/core/util/error.js
deleted file mode 100644
index 4dbdbc7..0000000
--- a/1.Vue/src/core/util/error.js
+++ /dev/null
@@ -1,83 +0,0 @@
-/* @flow */
-
-import config from '../config'
-import { warn } from './debug'
-import { inBrowser, inWeex } from './env'
-import { isPromise } from 'shared/util'
-import { pushTarget, popTarget } from '../observer/dep'
-
-export function handleError (err: Error, vm: any, info: string) {
-  // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
-  // See: https://github.com/vuejs/vuex/issues/1505
-  pushTarget()
-  try {
-    if (vm) {
-      let cur = vm
-      while ((cur = cur.$parent)) {
-        const hooks = cur.$options.errorCaptured
-        if (hooks) {
-          for (let i = 0; i < hooks.length; i++) {
-            try {
-              const capture = hooks[i].call(cur, err, vm, info) === false
-              if (capture) return
-            } catch (e) {
-              globalHandleError(e, cur, 'errorCaptured hook')
-            }
-          }
-        }
-      }
-    }
-    globalHandleError(err, vm, info)
-  } finally {
-    popTarget()
-  }
-}
-
-export function invokeWithErrorHandling (
-  handler: Function,
-  context: any,
-  args: null | any[],
-  vm: any,
-  info: string
-) {
-  let res
-  try {
-    res = args ? handler.apply(context, args) : handler.call(context)
-    if (res && !res._isVue && isPromise(res) && !res._handled) {
-      res.catch(e => handleError(e, vm, info + ` (Promise/async)`))
-      // issue #9511
-      // avoid catch triggering multiple times when nested calls
-      res._handled = true
-    }
-  } catch (e) {
-    handleError(e, vm, info)
-  }
-  return res
-}
-
-function globalHandleError (err, vm, info) {
-  if (config.errorHandler) {
-    try {
-      return config.errorHandler.call(null, err, vm, info)
-    } catch (e) {
-      // if the user intentionally throws the original error in the handler,
-      // do not log it twice
-      if (e !== err) {
-        logError(e, null, 'config.errorHandler')
-      }
-    }
-  }
-  logError(err, vm, info)
-}
-
-function logError (err, vm, info) {
-  if (process.env.NODE_ENV !== 'production') {
-    warn(`Error in ${info}: "${err.toString()}"`, vm)
-  }
-  /* istanbul ignore else */
-  if ((inBrowser || inWeex) && typeof console !== 'undefined') {
-    console.error(err)
-  } else {
-    throw err
-  }
-}
diff --git a/1.Vue/src/core/util/index.js b/1.Vue/src/core/util/index.js
deleted file mode 100644
index 115d77c..0000000
--- a/1.Vue/src/core/util/index.js
+++ /dev/null
@@ -1,11 +0,0 @@
-/* @flow */
-
-export * from 'shared/util'
-export * from './lang'
-export * from './env'
-export * from './options'
-export * from './debug'
-export * from './props'
-export * from './error'
-export * from './next-tick'
-export { defineReactive } from '../observer/index'
diff --git a/1.Vue/src/core/util/lang.js b/1.Vue/src/core/util/lang.js
deleted file mode 100644
index 8943694..0000000
--- a/1.Vue/src/core/util/lang.js
+++ /dev/null
@@ -1,46 +0,0 @@
-/* @flow */
-
-/**
- * unicode letters used for parsing html tags, component names and property paths.
- * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
- * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
- */
-export const unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/
-
-/**
- * Check if a string starts with $ or _
- */
-export function isReserved (str: string): boolean {
-  const c = (str + '').charCodeAt(0)
-  return c === 0x24 || c === 0x5F
-}
-
-/**
- * Define a property.
- */
-export function def (obj: Object, key: string, val: any, enumerable?: boolean) {
-  Object.defineProperty(obj, key, {
-    value: val,
-    enumerable: !!enumerable,
-    writable: true,
-    configurable: true
-  })
-}
-
-/**
- * Parse simple path.
- */
-const bailRE = new RegExp(`[^${unicodeRegExp.source}.$_\\d]`)
-export function parsePath (path: string): any {
-  if (bailRE.test(path)) {
-    return
-  }
-  const segments = path.split('.')
-  return function (obj) {
-    for (let i = 0; i < segments.length; i++) {
-      if (!obj) return
-      obj = obj[segments[i]]
-    }
-    return obj
-  }
-}
diff --git a/1.Vue/src/core/util/next-tick.js b/1.Vue/src/core/util/next-tick.js
deleted file mode 100644
index ae08ea4..0000000
--- a/1.Vue/src/core/util/next-tick.js
+++ /dev/null
@@ -1,110 +0,0 @@
-/* @flow */
-/* globals MutationObserver */
-
-import { noop } from 'shared/util'
-import { handleError } from './error'
-import { isIE, isIOS, isNative } from './env'
-
-export let isUsingMicroTask = false
-
-const callbacks = []
-let pending = false
-
-function flushCallbacks () {
-  pending = false
-  const copies = callbacks.slice(0)
-  callbacks.length = 0
-  for (let i = 0; i < copies.length; i++) {
-    copies[i]()
-  }
-}
-
-// Here we have async deferring wrappers using microtasks.
-// In 2.5 we used (macro) tasks (in combination with microtasks).
-// However, it has subtle problems when state is changed right before repaint
-// (e.g. #6813, out-in transitions).
-// Also, using (macro) tasks in event handler would cause some weird behaviors
-// that cannot be circumvented (e.g. #7109, #7153, #7546, #7834, #8109).
-// So we now use microtasks everywhere, again.
-// A major drawback of this tradeoff is that there are some scenarios
-// where microtasks have too high a priority and fire in between supposedly
-// sequential events (e.g. #4521, #6690, which have workarounds)
-// or even between bubbling of the same event (#6566).
-let timerFunc
-
-// 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 next, $flow-disable-line */
-if (typeof Promise !== 'undefined' && isNative(Promise)) {
-  const p = Promise.resolve()
-  timerFunc = () => {
-    p.then(flushCallbacks)
-    // 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)
-  }
-  isUsingMicroTask = true
-} else if (!isIE && 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, iOS7, Android 4.4
-  // (#6466 MutationObserver is unreliable in IE11)
-  let counter = 1
-  const observer = new MutationObserver(flushCallbacks)
-  const textNode = document.createTextNode(String(counter))
-  observer.observe(textNode, {
-    characterData: true
-  })
-  timerFunc = () => {
-    counter = (counter + 1) % 2
-    textNode.data = String(counter)
-  }
-  isUsingMicroTask = true
-} else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {
-  // Fallback to setImmediate.
-  // Techinically it leverages the (macro) task queue,
-  // but it is still a better choice than setTimeout.
-  timerFunc = () => {
-    setImmediate(flushCallbacks)
-  }
-} else {
-  // Fallback to setTimeout.
-  timerFunc = () => {
-    setTimeout(flushCallbacks, 0)
-  }
-}
-
-export function nextTick (cb?: Function, ctx?: Object) {
-  let _resolve
-  callbacks.push(() => {
-    if (cb) {
-      try {
-        cb.call(ctx)
-      } catch (e) {
-        handleError(e, ctx, 'nextTick')
-      }
-    } else if (_resolve) {
-      _resolve(ctx)
-    }
-  })
-  if (!pending) {
-    pending = true
-    timerFunc()
-  }
-  // $flow-disable-line
-  if (!cb && typeof Promise !== 'undefined') {
-    return new Promise(resolve => {
-      _resolve = resolve
-    })
-  }
-}
diff --git a/1.Vue/src/core/util/options.js b/1.Vue/src/core/util/options.js
deleted file mode 100644
index 2435678..0000000
--- a/1.Vue/src/core/util/options.js
+++ /dev/null
@@ -1,468 +0,0 @@
-/* @flow */
-
-import config from '../config'
-import { warn } from './debug'
-import { set } from '../observer/index'
-import { unicodeRegExp } from './lang'
-import { nativeWatch, hasSymbol } from './env'
-
-import {
-  ASSET_TYPES,
-  LIFECYCLE_HOOKS
-} from 'shared/constants'
-
-import {
-  extend,
-  hasOwn,
-  camelize,
-  toRawType,
-  capitalize,
-  isBuiltInTag,
-  isPlainObject
-} from 'shared/util'
-
-/**
- * Option overwriting strategies are functions that handle
- * how to merge a parent option value and a child option
- * value into the final value.
- */
-const strats = config.optionMergeStrategies
-
-/**
- * Options with restrictions
- */
-if (process.env.NODE_ENV !== 'production') {
-  strats.el = strats.propsData = function (parent, child, vm, key) {
-    if (!vm) {
-      warn(
-        `option "${key}" can only be used during instance ` +
-        'creation with the `new` keyword.'
-      )
-    }
-    return defaultStrat(parent, child)
-  }
-}
-
-/**
- * Helper that recursively merges two data objects together.
- */
-function mergeData (to: Object, from: ?Object): Object {
-  if (!from) return to
-  let key, toVal, fromVal
-
-  const keys = hasSymbol
-    ? Reflect.ownKeys(from)
-    : Object.keys(from)
-
-  for (let i = 0; i < keys.length; i++) {
-    key = keys[i]
-    // in case the object is already observed...
-    if (key === '__ob__') continue
-    toVal = to[key]
-    fromVal = from[key]
-    if (!hasOwn(to, key)) {
-      set(to, key, fromVal)
-    } else if (
-      toVal !== fromVal &&
-      isPlainObject(toVal) &&
-      isPlainObject(fromVal)
-    ) {
-      mergeData(toVal, fromVal)
-    }
-  }
-  return to
-}
-
-/**
- * Data
- */
-export function mergeDataOrFn (
-  parentVal: any,
-  childVal: any,
-  vm?: Component
-): ?Function {
-  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, this) : childVal,
-        typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal
-      )
-    }
-  } else {
-    return function mergedInstanceDataFn () {
-      // instance merge
-      const instanceData = typeof childVal === 'function'
-        ? childVal.call(vm, vm)
-        : childVal
-      const defaultData = typeof parentVal === 'function'
-        ? parentVal.call(vm, vm)
-        : parentVal
-      if (instanceData) {
-        return mergeData(instanceData, defaultData)
-      } else {
-        return defaultData
-      }
-    }
-  }
-}
-
-strats.data = function (
-  parentVal: any,
-  childVal: any,
-  vm?: Component
-): ?Function {
-  if (!vm) {
-    if (childVal && typeof childVal !== 'function') {
-      process.env.NODE_ENV !== 'production' && warn(
-        'The "data" option should be a function ' +
-        'that returns a per-instance value in component ' +
-        'definitions.',
-        vm
-      )
-
-      return parentVal
-    }
-    return mergeDataOrFn(parentVal, childVal)
-  }
-
-  return mergeDataOrFn(parentVal, childVal, vm)
-}
-
-/**
- * Hooks and props are merged as arrays.
- */
-function mergeHook (
-  parentVal: ?Array<Function>,
-  childVal: ?Function | ?Array<Function>
-): ?Array<Function> {
-  const res = childVal
-    ? parentVal
-      ? parentVal.concat(childVal)
-      : Array.isArray(childVal)
-        ? childVal
-        : [childVal]
-    : parentVal
-  return res
-    ? dedupeHooks(res)
-    : res
-}
-
-function dedupeHooks (hooks) {
-  const res = []
-  for (let i = 0; i < hooks.length; i++) {
-    if (res.indexOf(hooks[i]) === -1) {
-      res.push(hooks[i])
-    }
-  }
-  return res
-}
-
-LIFECYCLE_HOOKS.forEach(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: ?Object,
-  childVal: ?Object,
-  vm?: Component,
-  key: string
-): Object {
-  const res = Object.create(parentVal || null)
-  if (childVal) {
-    process.env.NODE_ENV !== 'production' && assertObjectType(key, childVal, vm)
-    return extend(res, childVal)
-  } else {
-    return 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: ?Object,
-  childVal: ?Object,
-  vm?: Component,
-  key: string
-): ?Object {
-  // 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 (process.env.NODE_ENV !== 'production') {
-    assertObjectType(key, childVal, vm)
-  }
-  if (!parentVal) return childVal
-  const ret = {}
-  extend(ret, parentVal)
-  for (const key in childVal) {
-    let parent = ret[key]
-    const 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: ?Object,
-  childVal: ?Object,
-  vm?: Component,
-  key: string
-): ?Object {
-  if (childVal && process.env.NODE_ENV !== 'production') {
-    assertObjectType(key, childVal, vm)
-  }
-  if (!parentVal) return childVal
-  const ret = Object.create(null)
-  extend(ret, parentVal)
-  if (childVal) extend(ret, childVal)
-  return ret
-}
-strats.provide = mergeDataOrFn
-
-/**
- * Default strategy.
- */
-const defaultStrat = function (parentVal: any, childVal: any): any {
-  return childVal === undefined
-    ? parentVal
-    : childVal
-}
-
-/**
- * Validate component names
- */
-function checkComponents (options: Object) {
-  for (const key in options.components) {
-    validateComponentName(key)
-  }
-}
-
-export function validateComponentName (name: string) {
-  if (!new RegExp(`^[a-zA-Z][\\-\\.0-9_${unicodeRegExp.source}]*$`).test(name)) {
-    warn(
-      'Invalid component name: "' + name + '". Component names ' +
-      'should conform to valid custom element name in html5 specification.'
-    )
-  }
-  if (isBuiltInTag(name) || config.isReservedTag(name)) {
-    warn(
-      'Do not use built-in or reserved HTML elements as component ' +
-      'id: ' + name
-    )
-  }
-}
-
-/**
- * Ensure all props option syntax are normalized into the
- * Object-based format.
- */
-function normalizeProps (options: Object, vm: ?Component) {
-  const props = options.props
-  if (!props) return
-  const res = {}
-  let 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 if (process.env.NODE_ENV !== 'production') {
-        warn('props must be strings when using array syntax.')
-      }
-    }
-  } else if (isPlainObject(props)) {
-    for (const key in props) {
-      val = props[key]
-      name = camelize(key)
-      res[name] = isPlainObject(val)
-        ? val
-        : { type: val }
-    }
-  } else if (process.env.NODE_ENV !== 'production') {
-    warn(
-      `Invalid value for option "props": expected an Array or an Object, ` +
-      `but got ${toRawType(props)}.`,
-      vm
-    )
-  }
-  options.props = res
-}
-
-/**
- * Normalize all injections into Object-based format
- */
-function normalizeInject (options: Object, vm: ?Component) {
-  const inject = options.inject
-  if (!inject) return
-  const normalized = options.inject = {}
-  if (Array.isArray(inject)) {
-    for (let i = 0; i < inject.length; i++) {
-      normalized[inject[i]] = { from: inject[i] }
-    }
-  } else if (isPlainObject(inject)) {
-    for (const key in inject) {
-      const val = inject[key]
-      normalized[key] = isPlainObject(val)
-        ? extend({ from: key }, val)
-        : { from: val }
-    }
-  } else if (process.env.NODE_ENV !== 'production') {
-    warn(
-      `Invalid value for option "inject": expected an Array or an Object, ` +
-      `but got ${toRawType(inject)}.`,
-      vm
-    )
-  }
-}
-
-/**
- * Normalize raw function directives into object format.
- */
-function normalizeDirectives (options: Object) {
-  const dirs = options.directives
-  if (dirs) {
-    for (const key in dirs) {
-      const def = dirs[key]
-      if (typeof def === 'function') {
-        dirs[key] = { bind: def, update: def }
-      }
-    }
-  }
-}
-
-function assertObjectType (name: string, value: any, vm: ?Component) {
-  if (!isPlainObject(value)) {
-    warn(
-      `Invalid value for option "${name}": expected an Object, ` +
-      `but got ${toRawType(value)}.`,
-      vm
-    )
-  }
-}
-
-/**
- * Merge two option objects into a new one.
- * Core utility used in both instantiation and inheritance.
- */
-export function mergeOptions (
-  parent: Object,
-  child: Object,
-  vm?: Component
-): Object {
-  if (process.env.NODE_ENV !== 'production') {
-    checkComponents(child)
-  }
-
-  if (typeof child === 'function') {
-    child = child.options
-  }
-
-  normalizeProps(child, vm)
-  normalizeInject(child, vm)
-  normalizeDirectives(child)
-
-  // Apply extends and mixins on the child options,
-  // but only if it is a raw options object that isn't
-  // the result of another mergeOptions call.
-  // Only merged options has the _base property.
-  if (!child._base) {
-    if (child.extends) {
-      parent = mergeOptions(parent, child.extends, vm)
-    }
-    if (child.mixins) {
-      for (let i = 0, l = child.mixins.length; i < l; i++) {
-        parent = mergeOptions(parent, child.mixins[i], vm)
-      }
-    }
-  }
-
-  const options = {}
-  let key
-  for (key in parent) {
-    mergeField(key)
-  }
-  for (key in child) {
-    if (!hasOwn(parent, key)) {
-      mergeField(key)
-    }
-  }
-  function mergeField (key) {
-    const 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.
- */
-export function resolveAsset (
-  options: Object,
-  type: string,
-  id: string,
-  warnMissing?: boolean
-): any {
-  /* istanbul ignore if */
-  if (typeof id !== 'string') {
-    return
-  }
-  const assets = options[type]
-  // check local registration variations first
-  if (hasOwn(assets, id)) return assets[id]
-  const camelizedId = camelize(id)
-  if (hasOwn(assets, camelizedId)) return assets[camelizedId]
-  const PascalCaseId = capitalize(camelizedId)
-  if (hasOwn(assets, PascalCaseId)) return assets[PascalCaseId]
-  // fallback to prototype chain
-  const res = assets[id] || assets[camelizedId] || assets[PascalCaseId]
-  if (process.env.NODE_ENV !== 'production' && warnMissing && !res) {
-    warn(
-      'Failed to resolve ' + type.slice(0, -1) + ': ' + id,
-      options
-    )
-  }
-  return res
-}
diff --git a/1.Vue/src/core/util/perf.js b/1.Vue/src/core/util/perf.js
deleted file mode 100644
index c0c8a27..0000000
--- a/1.Vue/src/core/util/perf.js
+++ /dev/null
@@ -1,24 +0,0 @@
-import { inBrowser } from './env'
-
-export let mark
-export let measure
-
-if (process.env.NODE_ENV !== 'production') {
-  const perf = inBrowser && window.performance
-  /* istanbul ignore if */
-  if (
-    perf &&
-    perf.mark &&
-    perf.measure &&
-    perf.clearMarks &&
-    perf.clearMeasures
-  ) {
-    mark = tag => perf.mark(tag)
-    measure = (name, startTag, endTag) => {
-      perf.measure(name, startTag, endTag)
-      perf.clearMarks(startTag)
-      perf.clearMarks(endTag)
-      // perf.clearMeasures(name)
-    }
-  }
-}
diff --git a/1.Vue/src/core/util/props.js b/1.Vue/src/core/util/props.js
deleted file mode 100644
index 1b57f77..0000000
--- a/1.Vue/src/core/util/props.js
+++ /dev/null
@@ -1,241 +0,0 @@
-/* @flow */
-
-import { warn } from './debug'
-import { observe, toggleObserving, shouldObserve } from '../observer/index'
-import {
-  hasOwn,
-  isObject,
-  toRawType,
-  hyphenate,
-  capitalize,
-  isPlainObject
-} from 'shared/util'
-
-type PropOptions = {
-  type: Function | Array<Function> | null,
-  default: any,
-  required: ?boolean,
-  validator: ?Function
-};
-
-export function validateProp (
-  key: string,
-  propOptions: Object,
-  propsData: Object,
-  vm?: Component
-): any {
-  const prop = propOptions[key]
-  const absent = !hasOwn(propsData, key)
-  let value = propsData[key]
-  // boolean casting
-  const booleanIndex = getTypeIndex(Boolean, prop.type)
-  if (booleanIndex > -1) {
-    if (absent && !hasOwn(prop, 'default')) {
-      value = false
-    } else if (value === '' || value === hyphenate(key)) {
-      // only cast empty string / same name to boolean if
-      // boolean has higher priority
-      const stringIndex = getTypeIndex(String, prop.type)
-      if (stringIndex < 0 || booleanIndex < stringIndex) {
-        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.
-    const prevShouldObserve = shouldObserve
-    toggleObserving(true)
-    observe(value)
-    toggleObserving(prevShouldObserve)
-  }
-  if (
-    process.env.NODE_ENV !== 'production' &&
-    // skip validation for weex recycle-list child component props
-    !(__WEEX__ && isObject(value) && ('@binding' in value))
-  ) {
-    assertProp(prop, key, value, vm, absent)
-  }
-  return value
-}
-
-/**
- * Get the default value of a prop.
- */
-function getPropDefaultValue (vm: ?Component, prop: PropOptions, key: string): any {
-  // no default, return undefined
-  if (!hasOwn(prop, 'default')) {
-    return undefined
-  }
-  const def = prop.default
-  // warn against non-factory defaults for Object & Array
-  if (process.env.NODE_ENV !== '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
-}
-
-/**
- * Assert whether a prop is valid.
- */
-function assertProp (
-  prop: PropOptions,
-  name: string,
-  value: any,
-  vm: ?Component,
-  absent: boolean
-) {
-  if (prop.required && absent) {
-    warn(
-      'Missing required prop: "' + name + '"',
-      vm
-    )
-    return
-  }
-  if (value == null && !prop.required) {
-    return
-  }
-  let type = prop.type
-  let valid = !type || type === true
-  const expectedTypes = []
-  if (type) {
-    if (!Array.isArray(type)) {
-      type = [type]
-    }
-    for (let i = 0; i < type.length && !valid; i++) {
-      const assertedType = assertType(value, type[i])
-      expectedTypes.push(assertedType.expectedType || '')
-      valid = assertedType.valid
-    }
-  }
-
-  if (!valid) {
-    warn(
-      getInvalidTypeMessage(name, value, expectedTypes),
-      vm
-    )
-    return
-  }
-  const validator = prop.validator
-  if (validator) {
-    if (!validator(value)) {
-      warn(
-        'Invalid prop: custom validator check failed for prop "' + name + '".',
-        vm
-      )
-    }
-  }
-}
-
-const simpleCheckRE = /^(String|Number|Boolean|Function|Symbol)$/
-
-function assertType (value: any, type: Function): {
-  valid: boolean;
-  expectedType: string;
-} {
-  let valid
-  const expectedType = getType(type)
-  if (simpleCheckRE.test(expectedType)) {
-    const t = typeof value
-    valid = t === expectedType.toLowerCase()
-    // for primitive wrapper objects
-    if (!valid && t === 'object') {
-      valid = value instanceof type
-    }
-  } else if (expectedType === 'Object') {
-    valid = isPlainObject(value)
-  } else if (expectedType === 'Array') {
-    valid = Array.isArray(value)
-  } else {
-    valid = value instanceof type
-  }
-  return {
-    valid,
-    expectedType
-  }
-}
-
-/**
- * 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) {
-  const match = fn && fn.toString().match(/^\s*function (\w+)/)
-  return match ? match[1] : ''
-}
-
-function isSameType (a, b) {
-  return getType(a) === getType(b)
-}
-
-function getTypeIndex (type, expectedTypes): number {
-  if (!Array.isArray(expectedTypes)) {
-    return isSameType(expectedTypes, type) ? 0 : -1
-  }
-  for (let i = 0, len = expectedTypes.length; i < len; i++) {
-    if (isSameType(expectedTypes[i], type)) {
-      return i
-    }
-  }
-  return -1
-}
-
-function getInvalidTypeMessage (name, value, expectedTypes) {
-  let message = `Invalid prop: type check failed for prop "${name}".` +
-    ` Expected ${expectedTypes.map(capitalize).join(', ')}`
-  const expectedType = expectedTypes[0]
-  const receivedType = toRawType(value)
-  const expectedValue = styleValue(value, expectedType)
-  const receivedValue = styleValue(value, receivedType)
-  // check if we need to specify expected value
-  if (expectedTypes.length === 1 &&
-      isExplicable(expectedType) &&
-      !isBoolean(expectedType, receivedType)) {
-    message += ` with value ${expectedValue}`
-  }
-  message += `, got ${receivedType} `
-  // check if we need to specify received value
-  if (isExplicable(receivedType)) {
-    message += `with value ${receivedValue}.`
-  }
-  return message
-}
-
-function styleValue (value, type) {
-  if (type === 'String') {
-    return `"${value}"`
-  } else if (type === 'Number') {
-    return `${Number(value)}`
-  } else {
-    return `${value}`
-  }
-}
-
-function isExplicable (value) {
-  const explicitTypes = ['string', 'number', 'boolean']
-  return explicitTypes.some(elem => value.toLowerCase() === elem)
-}
-
-function isBoolean (...args) {
-  return args.some(elem => elem.toLowerCase() === 'boolean')
-}
diff --git a/1.Vue/src/core/vdom/create-component.js b/1.Vue/src/core/vdom/create-component.js
deleted file mode 100644
index 1e9bb21..0000000
--- a/1.Vue/src/core/vdom/create-component.js
+++ /dev/null
@@ -1,268 +0,0 @@
-/* @flow */
-
-import VNode from './vnode'
-import { resolveConstructorOptions } from 'core/instance/init'
-import { queueActivatedComponent } from 'core/observer/scheduler'
-import { createFunctionalComponent } from './create-functional-component'
-
-import {
-  warn,
-  isDef,
-  isUndef,
-  isTrue,
-  isObject
-} from '../util/index'
-
-import {
-  resolveAsyncComponent,
-  createAsyncPlaceholder,
-  extractPropsFromVNodeData
-} from './helpers/index'
-
-import {
-  callHook,
-  activeInstance,
-  updateChildComponent,
-  activateChildComponent,
-  deactivateChildComponent
-} from '../instance/lifecycle'
-
-import {
-  isRecyclableComponent,
-  renderRecyclableComponentTemplate
-} from 'weex/runtime/recycle-list/render-component-template'
-
-// inline hooks to be invoked on component VNodes during patch
-const componentVNodeHooks = {
-  init (vnode: VNodeWithData, hydrating: boolean): ?boolean {
-    if (
-      vnode.componentInstance &&
-      !vnode.componentInstance._isDestroyed &&
-      vnode.data.keepAlive
-    ) {
-      // kept-alive components, treat as a patch
-      const mountedNode: any = vnode // work around flow
-      componentVNodeHooks.prepatch(mountedNode, mountedNode)
-    } else {
-      const child = vnode.componentInstance = createComponentInstanceForVnode(
-        vnode,
-        activeInstance
-      )
-      child.$mount(hydrating ? vnode.elm : undefined, hydrating)
-    }
-  },
-
-  prepatch (oldVnode: MountedComponentVNode, vnode: MountedComponentVNode) {
-    const options = vnode.componentOptions
-    const child = vnode.componentInstance = oldVnode.componentInstance
-    updateChildComponent(
-      child,
-      options.propsData, // updated props
-      options.listeners, // updated listeners
-      vnode, // new parent vnode
-      options.children // new children
-    )
-  },
-
-  insert (vnode: MountedComponentVNode) {
-    const { context, componentInstance } = vnode
-    if (!componentInstance._isMounted) {
-      componentInstance._isMounted = true
-      callHook(componentInstance, 'mounted')
-    }
-    if (vnode.data.keepAlive) {
-      if (context._isMounted) {
-        // vue-router#1212
-        // During updates, a kept-alive component's child components may
-        // change, so directly walking the tree here may call activated hooks
-        // on incorrect children. Instead we push them into a queue which will
-        // be processed after the whole patch process ended.
-        queueActivatedComponent(componentInstance)
-      } else {
-        activateChildComponent(componentInstance, true /* direct */)
-      }
-    }
-  },
-
-  destroy (vnode: MountedComponentVNode) {
-    const { componentInstance } = vnode
-    if (!componentInstance._isDestroyed) {
-      if (!vnode.data.keepAlive) {
-        componentInstance.$destroy()
-      } else {
-        deactivateChildComponent(componentInstance, true /* direct */)
-      }
-    }
-  }
-}
-
-const hooksToMerge = Object.keys(componentVNodeHooks)
-
-export function createComponent (
-  Ctor: Class<Component> | Function | Object | void,
-  data: ?VNodeData,
-  context: Component,
-  children: ?Array<VNode>,
-  tag?: string
-): VNode | Array<VNode> | void {
-  if (isUndef(Ctor)) {
-    return
-  }
-
-  const baseCtor = context.$options._base
-
-  // plain options object: turn it into a constructor
-  if (isObject(Ctor)) {
-    Ctor = baseCtor.extend(Ctor)
-  }
-
-  // if at this stage it's not a constructor or an async component factory,
-  // reject.
-  if (typeof Ctor !== 'function') {
-    if (process.env.NODE_ENV !== 'production') {
-      warn(`Invalid Component definition: ${String(Ctor)}`, context)
-    }
-    return
-  }
-
-  // async component
-  let asyncFactory
-  if (isUndef(Ctor.cid)) {
-    asyncFactory = Ctor
-    Ctor = resolveAsyncComponent(asyncFactory, baseCtor)
-    if (Ctor === undefined) {
-      // return a placeholder node for async component, which is rendered
-      // as a comment node but preserves all the raw information for the node.
-      // the information will be used for async server-rendering and hydration.
-      return createAsyncPlaceholder(
-        asyncFactory,
-        data,
-        context,
-        children,
-        tag
-      )
-    }
-  }
-
-  data = data || {}
-
-  // resolve constructor options in case global mixins are applied after
-  // component constructor creation
-  resolveConstructorOptions(Ctor)
-
-  // transform component v-model data into props & events
-  if (isDef(data.model)) {
-    transformModel(Ctor.options, data)
-  }
-
-  // extract props
-  const propsData = extractPropsFromVNodeData(data, Ctor, tag)
-
-  // functional component
-  if (isTrue(Ctor.options.functional)) {
-    return createFunctionalComponent(Ctor, propsData, data, context, children)
-  }
-
-  // extract listeners, since these needs to be treated as
-  // child component listeners instead of DOM listeners
-  const listeners = data.on
-  // replace with listeners with .native modifier
-  // so it gets processed during parent component patch.
-  data.on = data.nativeOn
-
-  if (isTrue(Ctor.options.abstract)) {
-    // abstract components do not keep anything
-    // other than props & listeners & slot
-
-    // work around flow
-    const slot = data.slot
-    data = {}
-    if (slot) {
-      data.slot = slot
-    }
-  }
-
-  // install component management hooks onto the placeholder node
-  installComponentHooks(data)
-
-  // return a placeholder vnode
-  const name = Ctor.options.name || tag
-  const vnode = new VNode(
-    `vue-component-${Ctor.cid}${name ? `-${name}` : ''}`,
-    data, undefined, undefined, undefined, context,
-    { Ctor, propsData, listeners, tag, children },
-    asyncFactory
-  )
-
-  // Weex specific: invoke recycle-list optimized @render function for
-  // extracting cell-slot template.
-  // https://github.com/Hanks10100/weex-native-directive/tree/master/component
-  /* istanbul ignore if */
-  if (__WEEX__ && isRecyclableComponent(vnode)) {
-    return renderRecyclableComponentTemplate(vnode)
-  }
-
-  return vnode
-}
-
-export function createComponentInstanceForVnode (
-  vnode: any, // we know it's MountedComponentVNode but flow doesn't
-  parent: any, // activeInstance in lifecycle state
-): Component {
-  const options: InternalComponentOptions = {
-    _isComponent: true,
-    _parentVnode: vnode,
-    parent
-  }
-  // check inline-template render functions
-  const inlineTemplate = vnode.data.inlineTemplate
-  if (isDef(inlineTemplate)) {
-    options.render = inlineTemplate.render
-    options.staticRenderFns = inlineTemplate.staticRenderFns
-  }
-  return new vnode.componentOptions.Ctor(options)
-}
-
-function installComponentHooks (data: VNodeData) {
-  const hooks = data.hook || (data.hook = {})
-  for (let i = 0; i < hooksToMerge.length; i++) {
-    const key = hooksToMerge[i]
-    const existing = hooks[key]
-    const toMerge = componentVNodeHooks[key]
-    if (existing !== toMerge && !(existing && existing._merged)) {
-      hooks[key] = existing ? mergeHook(toMerge, existing) : toMerge
-    }
-  }
-}
-
-function mergeHook (f1: any, f2: any): Function {
-  const merged = (a, b) => {
-    // flow complains about extra args which is why we use any
-    f1(a, b)
-    f2(a, b)
-  }
-  merged._merged = true
-  return merged
-}
-
-// transform component v-model info (value and callback) into
-// prop and event handler respectively.
-function transformModel (options, data: any) {
-  const prop = (options.model && options.model.prop) || 'value'
-  const event = (options.model && options.model.event) || 'input'
-  ;(data.attrs || (data.attrs = {}))[prop] = data.model.value
-  const on = data.on || (data.on = {})
-  const existing = on[event]
-  const callback = data.model.callback
-  if (isDef(existing)) {
-    if (
-      Array.isArray(existing)
-        ? existing.indexOf(callback) === -1
-        : existing !== callback
-    ) {
-      on[event] = [callback].concat(existing)
-    }
-  } else {
-    on[event] = callback
-  }
-}
diff --git a/1.Vue/src/core/vdom/create-element.js b/1.Vue/src/core/vdom/create-element.js
deleted file mode 100644
index 4602708..0000000
--- a/1.Vue/src/core/vdom/create-element.js
+++ /dev/null
@@ -1,160 +0,0 @@
-/* @flow */
-
-import config from '../config'
-import VNode, { createEmptyVNode } from './vnode'
-import { createComponent } from './create-component'
-import { traverse } from '../observer/traverse'
-
-import {
-  warn,
-  isDef,
-  isUndef,
-  isTrue,
-  isObject,
-  isPrimitive,
-  resolveAsset
-} from '../util/index'
-
-import {
-  normalizeChildren,
-  simpleNormalizeChildren
-} from './helpers/index'
-
-const SIMPLE_NORMALIZE = 1
-const ALWAYS_NORMALIZE = 2
-
-// wrapper function for providing a more flexible interface
-// without getting yelled at by flow
-export function createElement (
-  context: Component,
-  tag: any,
-  data: any,
-  children: any,
-  normalizationType: any,
-  alwaysNormalize: boolean
-): VNode | Array<VNode> {
-  if (Array.isArray(data) || isPrimitive(data)) {
-    normalizationType = children
-    children = data
-    data = undefined
-  }
-  if (isTrue(alwaysNormalize)) {
-    normalizationType = ALWAYS_NORMALIZE
-  }
-  return _createElement(context, tag, data, children, normalizationType)
-}
-
-export function _createElement (
-  context: Component,
-  tag?: string | Class<Component> | Function | Object,
-  data?: VNodeData,
-  children?: any,
-  normalizationType?: number
-): VNode | Array<VNode> {
-  if (isDef(data) && isDef((data: any).__ob__)) {
-    process.env.NODE_ENV !== 'production' && warn(
-      `Avoid using observed data object as vnode data: ${JSON.stringify(data)}\n` +
-      'Always create fresh vnode data objects in each render!',
-      context
-    )
-    return createEmptyVNode()
-  }
-  // object syntax in v-bind
-  if (isDef(data) && isDef(data.is)) {
-    tag = data.is
-  }
-  if (!tag) {
-    // in case of component :is set to falsy value
-    return createEmptyVNode()
-  }
-  // warn against non-primitive key
-  if (process.env.NODE_ENV !== 'production' &&
-    isDef(data) && isDef(data.key) && !isPrimitive(data.key)
-  ) {
-    if (!__WEEX__ || !('@binding' in data.key)) {
-      warn(
-        'Avoid using non-primitive value as key, ' +
-        'use string/number value instead.',
-        context
-      )
-    }
-  }
-  // support single function children as default scoped slot
-  if (Array.isArray(children) &&
-    typeof children[0] === 'function'
-  ) {
-    data = data || {}
-    data.scopedSlots = { default: children[0] }
-    children.length = 0
-  }
-  if (normalizationType === ALWAYS_NORMALIZE) {
-    children = normalizeChildren(children)
-  } else if (normalizationType === SIMPLE_NORMALIZE) {
-    children = simpleNormalizeChildren(children)
-  }
-  let vnode, ns
-  if (typeof tag === 'string') {
-    let Ctor
-    ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag)
-    if (config.isReservedTag(tag)) {
-      // platform built-in elements
-      vnode = new VNode(
-        config.parsePlatformTagName(tag), data, children,
-        undefined, undefined, context
-      )
-    } else if ((!data || !data.pre) && isDef(Ctor = resolveAsset(context.$options, 'components', tag))) {
-      // component
-      vnode = createComponent(Ctor, data, context, children, tag)
-    } else {
-      // unknown or unlisted namespaced elements
-      // check at runtime because it may get assigned a namespace when its
-      // parent normalizes children
-      vnode = new VNode(
-        tag, data, children,
-        undefined, undefined, context
-      )
-    }
-  } else {
-    // direct component options / constructor
-    vnode = createComponent(tag, data, context, children)
-  }
-  if (Array.isArray(vnode)) {
-    return vnode
-  } else if (isDef(vnode)) {
-    if (isDef(ns)) applyNS(vnode, ns)
-    if (isDef(data)) registerDeepBindings(data)
-    return vnode
-  } else {
-    return createEmptyVNode()
-  }
-}
-
-function applyNS (vnode, ns, force) {
-  vnode.ns = ns
-  if (vnode.tag === 'foreignObject') {
-    // use default namespace inside foreignObject
-    ns = undefined
-    force = true
-  }
-  if (isDef(vnode.children)) {
-    for (let i = 0, l = vnode.children.length; i < l; i++) {
-      const child = vnode.children[i]
-      if (isDef(child.tag) && (
-        isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
-        applyNS(child, ns, force)
-      }
-    }
-  }
-}
-
-// ref #5318
-// necessary to ensure parent re-render when deep bindings like :style and
-// :class are used on slot nodes
-function registerDeepBindings (data) {
-  if (isObject(data.style)) {
-    traverse(data.style)
-  }
-  if (isObject(data.class)) {
-    traverse(data.class)
-  }
-}
diff --git a/1.Vue/src/core/vdom/create-functional-component.js b/1.Vue/src/core/vdom/create-functional-component.js
deleted file mode 100644
index c6edf65..0000000
--- a/1.Vue/src/core/vdom/create-functional-component.js
+++ /dev/null
@@ -1,155 +0,0 @@
-/* @flow */
-
-import VNode, { cloneVNode } from './vnode'
-import { createElement } from './create-element'
-import { resolveInject } from '../instance/inject'
-import { normalizeChildren } from '../vdom/helpers/normalize-children'
-import { resolveSlots } from '../instance/render-helpers/resolve-slots'
-import { normalizeScopedSlots } from '../vdom/helpers/normalize-scoped-slots'
-import { installRenderHelpers } from '../instance/render-helpers/index'
-
-import {
-  isDef,
-  isTrue,
-  hasOwn,
-  camelize,
-  emptyObject,
-  validateProp
-} from '../util/index'
-
-export function FunctionalRenderContext (
-  data: VNodeData,
-  props: Object,
-  children: ?Array<VNode>,
-  parent: Component,
-  Ctor: Class<Component>
-) {
-  const options = Ctor.options
-  // ensure the createElement function in functional components
-  // gets a unique context - this is necessary for correct named slot check
-  let contextVm
-  if (hasOwn(parent, '_uid')) {
-    contextVm = Object.create(parent)
-    // $flow-disable-line
-    contextVm._original = parent
-  } else {
-    // the context vm passed in is a functional context as well.
-    // in this case we want to make sure we are able to get a hold to the
-    // real context instance.
-    contextVm = parent
-    // $flow-disable-line
-    parent = parent._original
-  }
-  const isCompiled = isTrue(options._compiled)
-  const needNormalization = !isCompiled
-
-  this.data = data
-  this.props = props
-  this.children = children
-  this.parent = parent
-  this.listeners = data.on || emptyObject
-  this.injections = resolveInject(options.inject, parent)
-  this.slots = () => {
-    if (!this.$slots) {
-      normalizeScopedSlots(
-        data.scopedSlots,
-        this.$slots = resolveSlots(children, parent)
-      )
-    }
-    return this.$slots
-  }
-
-  Object.defineProperty(this, 'scopedSlots', ({
-    enumerable: true,
-    get () {
-      return normalizeScopedSlots(data.scopedSlots, this.slots())
-    }
-  }: any))
-
-  // support for compiled functional template
-  if (isCompiled) {
-    // exposing $options for renderStatic()
-    this.$options = options
-    // pre-resolve slots for renderSlot()
-    this.$slots = this.slots()
-    this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots)
-  }
-
-  if (options._scopeId) {
-    this._c = (a, b, c, d) => {
-      const vnode = createElement(contextVm, a, b, c, d, needNormalization)
-      if (vnode && !Array.isArray(vnode)) {
-        vnode.fnScopeId = options._scopeId
-        vnode.fnContext = parent
-      }
-      return vnode
-    }
-  } else {
-    this._c = (a, b, c, d) => createElement(contextVm, a, b, c, d, needNormalization)
-  }
-}
-
-installRenderHelpers(FunctionalRenderContext.prototype)
-
-export function createFunctionalComponent (
-  Ctor: Class<Component>,
-  propsData: ?Object,
-  data: VNodeData,
-  contextVm: Component,
-  children: ?Array<VNode>
-): VNode | Array<VNode> | void {
-  const options = Ctor.options
-  const props = {}
-  const propOptions = options.props
-  if (isDef(propOptions)) {
-    for (const key in propOptions) {
-      props[key] = validateProp(key, propOptions, propsData || emptyObject)
-    }
-  } else {
-    if (isDef(data.attrs)) mergeProps(props, data.attrs)
-    if (isDef(data.props)) mergeProps(props, data.props)
-  }
-
-  const renderContext = new FunctionalRenderContext(
-    data,
-    props,
-    children,
-    contextVm,
-    Ctor
-  )
-
-  const vnode = options.render.call(null, renderContext._c, renderContext)
-
-  if (vnode instanceof VNode) {
-    return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext)
-  } else if (Array.isArray(vnode)) {
-    const vnodes = normalizeChildren(vnode) || []
-    const res = new Array(vnodes.length)
-    for (let i = 0; i < vnodes.length; i++) {
-      res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext)
-    }
-    return res
-  }
-}
-
-function cloneAndMarkFunctionalResult (vnode, data, contextVm, options, renderContext) {
-  // #7817 clone node before setting fnContext, otherwise if the node is reused
-  // (e.g. it was from a cached normal slot) the fnContext causes named slots
-  // that should not be matched to match.
-  const clone = cloneVNode(vnode)
-  clone.fnContext = contextVm
-  clone.fnOptions = options
-  if (process.env.NODE_ENV !== 'production') {
-    (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext
-  }
-  if (data.slot) {
-    (clone.data || (clone.data = {})).slot = data.slot
-  }
-  return clone
-}
-
-function mergeProps (to, from) {
-  for (const key in from) {
-    to[camelize(key)] = from[key]
-  }
-}
diff --git a/1.Vue/src/core/vdom/helpers/extract-props.js b/1.Vue/src/core/vdom/helpers/extract-props.js
deleted file mode 100644
index f2a4166..0000000
--- a/1.Vue/src/core/vdom/helpers/extract-props.js
+++ /dev/null
@@ -1,75 +0,0 @@
-/* @flow */
-
-import {
-  tip,
-  hasOwn,
-  isDef,
-  isUndef,
-  hyphenate,
-  formatComponentName
-} from 'core/util/index'
-
-export function extractPropsFromVNodeData (
-  data: VNodeData,
-  Ctor: Class<Component>,
-  tag?: string
-): ?Object {
-  // we are only extracting raw values here.
-  // validation and default values are handled in the child
-  // component itself.
-  const propOptions = Ctor.options.props
-  if (isUndef(propOptions)) {
-    return
-  }
-  const res = {}
-  const { attrs, props } = data
-  if (isDef(attrs) || isDef(props)) {
-    for (const key in propOptions) {
-      const altKey = hyphenate(key)
-      if (process.env.NODE_ENV !== 'production') {
-        const keyInLowerCase = key.toLowerCase()
-        if (
-          key !== keyInLowerCase &&
-          attrs && hasOwn(attrs, keyInLowerCase)
-        ) {
-          tip(
-            `Prop "${keyInLowerCase}" is passed to component ` +
-            `${formatComponentName(tag || Ctor)}, but the declared prop name is` +
-            ` "${key}". ` +
-            `Note that HTML attributes are case-insensitive and camelCased ` +
-            `props need to use their kebab-case equivalents when using in-DOM ` +
-            `templates. You should probably use "${altKey}" instead of "${key}".`
-          )
-        }
-      }
-      checkProp(res, props, key, altKey, true) ||
-      checkProp(res, attrs, key, altKey, false)
-    }
-  }
-  return res
-}
-
-function checkProp (
-  res: Object,
-  hash: ?Object,
-  key: string,
-  altKey: string,
-  preserve: boolean
-): boolean {
-  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
-}
diff --git a/1.Vue/src/core/vdom/helpers/get-first-component-child.js b/1.Vue/src/core/vdom/helpers/get-first-component-child.js
deleted file mode 100644
index f8649dd..0000000
--- a/1.Vue/src/core/vdom/helpers/get-first-component-child.js
+++ /dev/null
@@ -1,15 +0,0 @@
-/* @flow */
-
-import { isDef } from 'shared/util'
-import { isAsyncPlaceholder } from './is-async-placeholder'
-
-export function getFirstComponentChild (children: ?Array<VNode>): ?VNode {
-  if (Array.isArray(children)) {
-    for (let i = 0; i < children.length; i++) {
-      const c = children[i]
-      if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {
-        return c
-      }
-    }
-  }
-}
diff --git a/1.Vue/src/core/vdom/helpers/index.js b/1.Vue/src/core/vdom/helpers/index.js
deleted file mode 100644
index 320cf4c..0000000
--- a/1.Vue/src/core/vdom/helpers/index.js
+++ /dev/null
@@ -1,9 +0,0 @@
-/* @flow */
-
-export * from './merge-hook'
-export * from './extract-props'
-export * from './update-listeners'
-export * from './normalize-children'
-export * from './resolve-async-component'
-export * from './get-first-component-child'
-export * from './is-async-placeholder'
diff --git a/1.Vue/src/core/vdom/helpers/is-async-placeholder.js b/1.Vue/src/core/vdom/helpers/is-async-placeholder.js
deleted file mode 100644
index 6c4a659..0000000
--- a/1.Vue/src/core/vdom/helpers/is-async-placeholder.js
+++ /dev/null
@@ -1,5 +0,0 @@
-/* @flow */
-
-export function isAsyncPlaceholder (node: VNode): boolean {
-  return node.isComment && node.asyncFactory
-}
diff --git a/1.Vue/src/core/vdom/helpers/merge-hook.js b/1.Vue/src/core/vdom/helpers/merge-hook.js
deleted file mode 100644
index 0bb96e8..0000000
--- a/1.Vue/src/core/vdom/helpers/merge-hook.js
+++ /dev/null
@@ -1,38 +0,0 @@
-/* @flow */
-
-import VNode from '../vnode'
-import { createFnInvoker } from './update-listeners'
-import { remove, isDef, isUndef, isTrue } from 'shared/util'
-
-export function mergeVNodeHook (def: Object, hookKey: string, hook: Function) {
-  if (def instanceof VNode) {
-    def = def.data.hook || (def.data.hook = {})
-  }
-  let invoker
-  const oldHook = def[hookKey]
-
-  function wrappedHook () {
-    hook.apply(this, arguments)
-    // important: remove merged hook to ensure it's called only once
-    // and prevent memory leak
-    remove(invoker.fns, wrappedHook)
-  }
-
-  if (isUndef(oldHook)) {
-    // no existing hook
-    invoker = createFnInvoker([wrappedHook])
-  } else {
-    /* istanbul ignore if */
-    if (isDef(oldHook.fns) && isTrue(oldHook.merged)) {
-      // already a merged invoker
-      invoker = oldHook
-      invoker.fns.push(wrappedHook)
-    } else {
-      // existing plain hook
-      invoker = createFnInvoker([oldHook, wrappedHook])
-    }
-  }
-
-  invoker.merged = true
-  def[hookKey] = invoker
-}
diff --git a/1.Vue/src/core/vdom/helpers/normalize-children.js b/1.Vue/src/core/vdom/helpers/normalize-children.js
deleted file mode 100644
index a4622ef..0000000
--- a/1.Vue/src/core/vdom/helpers/normalize-children.js
+++ /dev/null
@@ -1,89 +0,0 @@
-/* @flow */
-
-import VNode, { createTextVNode } from 'core/vdom/vnode'
-import { isFalse, isTrue, isDef, isUndef, isPrimitive } from 'shared/util'
-
-// 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<VNode>. 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.
-export function simpleNormalizeChildren (children: any) {
-  for (let 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. <template>, <slot>, v-for, or when the children is provided by user
-// with hand-written render functions / JSX. In such cases a full normalization
-// is needed to cater to all possible types of children values.
-export function normalizeChildren (children: any): ?Array<VNode> {
-  return isPrimitive(children)
-    ? [createTextVNode(children)]
-    : Array.isArray(children)
-      ? normalizeArrayChildren(children)
-      : undefined
-}
-
-function isTextNode (node): boolean {
-  return isDef(node) && isDef(node.text) && isFalse(node.isComment)
-}
-
-function normalizeArrayChildren (children: any, nestedIndex?: string): Array<VNode> {
-  const res = []
-  let i, c, lastIndex, last
-  for (i = 0; i < children.length; i++) {
-    c = children[i]
-    if (isUndef(c) || typeof c === 'boolean') continue
-    lastIndex = res.length - 1
-    last = res[lastIndex]
-    //  nested
-    if (Array.isArray(c)) {
-      if (c.length > 0) {
-        c = normalizeArrayChildren(c, `${nestedIndex || ''}_${i}`)
-        // merge adjacent text nodes
-        if (isTextNode(c[0]) && isTextNode(last)) {
-          res[lastIndex] = createTextVNode(last.text + (c[0]: any).text)
-          c.shift()
-        }
-        res.push.apply(res, c)
-      }
-    } else if (isPrimitive(c)) {
-      if (isTextNode(last)) {
-        // merge adjacent text nodes
-        // this is necessary for SSR hydration because text nodes are
-        // essentially merged when rendered to HTML strings
-        res[lastIndex] = createTextVNode(last.text + c)
-      } else if (c !== '') {
-        // convert primitive to vnode
-        res.push(createTextVNode(c))
-      }
-    } else {
-      if (isTextNode(c) && isTextNode(last)) {
-        // merge adjacent text nodes
-        res[lastIndex] = createTextVNode(last.text + c.text)
-      } else {
-        // default key for nested array children (likely generated by v-for)
-        if (isTrue(children._isVList) &&
-          isDef(c.tag) &&
-          isUndef(c.key) &&
-          isDef(nestedIndex)) {
-          c.key = `__vlist${nestedIndex}_${i}__`
-        }
-        res.push(c)
-      }
-    }
-  }
-  return res
-}
diff --git a/1.Vue/src/core/vdom/helpers/normalize-scoped-slots.js b/1.Vue/src/core/vdom/helpers/normalize-scoped-slots.js
deleted file mode 100644
index 1e43fd3..0000000
--- a/1.Vue/src/core/vdom/helpers/normalize-scoped-slots.js
+++ /dev/null
@@ -1,84 +0,0 @@
-/* @flow */
-
-import { def } from 'core/util/lang'
-import { normalizeChildren } from 'core/vdom/helpers/normalize-children'
-import { emptyObject } from 'shared/util'
-
-export function normalizeScopedSlots (
-  slots: { [key: string]: Function } | void,
-  normalSlots: { [key: string]: Array<VNode> },
-  prevSlots?: { [key: string]: Function } | void
-): any {
-  let res
-  const hasNormalSlots = Object.keys(normalSlots).length > 0
-  const isStable = slots ? !!slots.$stable : !hasNormalSlots
-  const key = slots && slots.$key
-  if (!slots) {
-    res = {}
-  } else if (slots._normalized) {
-    // fast path 1: child component re-render only, parent did not change
-    return slots._normalized
-  } else if (
-    isStable &&
-    prevSlots &&
-    prevSlots !== emptyObject &&
-    key === prevSlots.$key &&
-    !hasNormalSlots &&
-    !prevSlots.$hasNormal
-  ) {
-    // fast path 2: stable scoped slots w/ no normal slots to proxy,
-    // only need to normalize once
-    return prevSlots
-  } else {
-    res = {}
-    for (const key in slots) {
-      if (slots[key] && key[0] !== '$') {
-        res[key] = normalizeScopedSlot(normalSlots, key, slots[key])
-      }
-    }
-  }
-  // expose normal slots on scopedSlots
-  for (const key in normalSlots) {
-    if (!(key in res)) {
-      res[key] = proxyNormalSlot(normalSlots, key)
-    }
-  }
-  // avoriaz seems to mock a non-extensible $scopedSlots object
-  // and when that is passed down this would cause an error
-  if (slots && Object.isExtensible(slots)) {
-    (slots: any)._normalized = res
-  }
-  def(res, '$stable', isStable)
-  def(res, '$key', key)
-  def(res, '$hasNormal', hasNormalSlots)
-  return res
-}
-
-function normalizeScopedSlot(normalSlots, key, fn) {
-  const normalized = function () {
-    let res = arguments.length ? fn.apply(null, arguments) : fn({})
-    res = res && typeof res === 'object' && !Array.isArray(res)
-      ? [res] // single vnode
-      : normalizeChildren(res)
-    return res && (
-      res.length === 0 ||
-      (res.length === 1 && res[0].isComment) // #9658
-    ) ? undefined
-      : res
-  }
-  // this is a slot using the new v-slot syntax without scope. although it is
-  // compiled as a scoped slot, render fn users would expect it to be present
-  // on this.$slots because the usage is semantically a normal slot.
-  if (fn.proxy) {
-    Object.defineProperty(normalSlots, key, {
-      get: normalized,
-      enumerable: true,
-      configurable: true
-    })
-  }
-  return normalized
-}
-
-function proxyNormalSlot(slots, key) {
-  return () => slots[key]
-}
diff --git a/1.Vue/src/core/vdom/helpers/resolve-async-component.js b/1.Vue/src/core/vdom/helpers/resolve-async-component.js
deleted file mode 100644
index 5fc00fa..0000000
--- a/1.Vue/src/core/vdom/helpers/resolve-async-component.js
+++ /dev/null
@@ -1,165 +0,0 @@
-/* @flow */
-
-import {
-  warn,
-  once,
-  isDef,
-  isUndef,
-  isTrue,
-  isObject,
-  hasSymbol,
-  isPromise,
-  remove
-} from 'core/util/index'
-
-import { createEmptyVNode } from 'core/vdom/vnode'
-import { currentRenderingInstance } from 'core/instance/render'
-
-function ensureCtor (comp: any, base) {
-  if (
-    comp.__esModule ||
-    (hasSymbol && comp[Symbol.toStringTag] === 'Module')
-  ) {
-    comp = comp.default
-  }
-  return isObject(comp)
-    ? base.extend(comp)
-    : comp
-}
-
-export function createAsyncPlaceholder (
-  factory: Function,
-  data: ?VNodeData,
-  context: Component,
-  children: ?Array<VNode>,
-  tag: ?string
-): VNode {
-  const node = createEmptyVNode()
-  node.asyncFactory = factory
-  node.asyncMeta = { data, context, children, tag }
-  return node
-}
-
-export function resolveAsyncComponent (
-  factory: Function,
-  baseCtor: Class<Component>
-): Class<Component> | void {
-  if (isTrue(factory.error) && isDef(factory.errorComp)) {
-    return factory.errorComp
-  }
-
-  if (isDef(factory.resolved)) {
-    return factory.resolved
-  }
-
-  const owner = currentRenderingInstance
-  if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {
-    // already pending
-    factory.owners.push(owner)
-  }
-
-  if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
-    return factory.loadingComp
-  }
-
-  if (owner && !isDef(factory.owners)) {
-    const owners = factory.owners = [owner]
-    let sync = true
-    let timerLoading = null
-    let timerTimeout = null
-
-    ;(owner: any).$on('hook:destroyed', () => remove(owners, owner))
-
-    const forceRender = (renderCompleted: boolean) => {
-      for (let i = 0, l = owners.length; i < l; i++) {
-        (owners[i]: any).$forceUpdate()
-      }
-
-      if (renderCompleted) {
-        owners.length = 0
-        if (timerLoading !== null) {
-          clearTimeout(timerLoading)
-          timerLoading = null
-        }
-        if (timerTimeout !== null) {
-          clearTimeout(timerTimeout)
-          timerTimeout = null
-        }
-      }
-    }
-
-    const resolve = once((res: Object | Class<Component>) => {
-      // cache resolved
-      factory.resolved = ensureCtor(res, baseCtor)
-      // invoke callbacks only if this is not a synchronous resolve
-      // (async resolves are shimmed as synchronous during SSR)
-      if (!sync) {
-        forceRender(true)
-      } else {
-        owners.length = 0
-      }
-    })
-
-    const reject = once(reason => {
-      process.env.NODE_ENV !== 'production' && warn(
-        `Failed to resolve async component: ${String(factory)}` +
-        (reason ? `\nReason: ${reason}` : '')
-      )
-      if (isDef(factory.errorComp)) {
-        factory.error = true
-        forceRender(true)
-      }
-    })
-
-    const res = factory(resolve, reject)
-
-    if (isObject(res)) {
-      if (isPromise(res)) {
-        // () => Promise
-        if (isUndef(factory.resolved)) {
-          res.then(resolve, reject)
-        }
-      } else if (isPromise(res.component)) {
-        res.component.then(resolve, reject)
-
-        if (isDef(res.error)) {
-          factory.errorComp = ensureCtor(res.error, baseCtor)
-        }
-
-        if (isDef(res.loading)) {
-          factory.loadingComp = ensureCtor(res.loading, baseCtor)
-          if (res.delay === 0) {
-            factory.loading = true
-          } else {
-            timerLoading = setTimeout(() => {
-              timerLoading = null
-              if (isUndef(factory.resolved) && isUndef(factory.error)) {
-                factory.loading = true
-                forceRender(false)
-              }
-            }, res.delay || 200)
-          }
-        }
-
-        if (isDef(res.timeout)) {
-          timerTimeout = setTimeout(() => {
-            timerTimeout = null
-            if (isUndef(factory.resolved)) {
-              reject(
-                process.env.NODE_ENV !== 'production'
-                  ? `timeout (${res.timeout}ms)`
-                  : null
-              )
-            }
-          }, res.timeout)
-        }
-      }
-    }
-
-    sync = false
-    // return in case resolved synchronously
-    return factory.loading
-      ? factory.loadingComp
-      : factory.resolved
-  }
-}
diff --git a/1.Vue/src/core/vdom/helpers/update-listeners.js b/1.Vue/src/core/vdom/helpers/update-listeners.js
deleted file mode 100644
index dcde7f4..0000000
--- a/1.Vue/src/core/vdom/helpers/update-listeners.js
+++ /dev/null
@@ -1,95 +0,0 @@
-/* @flow */
-
-import {
-  warn,
-  invokeWithErrorHandling
-} from 'core/util/index'
-import {
-  cached,
-  isUndef,
-  isTrue,
-  isPlainObject
-} from 'shared/util'
-
-const normalizeEvent = cached((name: string): {
-  name: string,
-  once: boolean,
-  capture: boolean,
-  passive: boolean,
-  handler?: Function,
-  params?: Array<any>
-} => {
-  const passive = name.charAt(0) === '&'
-  name = passive ? name.slice(1) : name
-  const once = name.charAt(0) === '~' // Prefixed last, checked first
-  name = once ? name.slice(1) : name
-  const capture = name.charAt(0) === '!'
-  name = capture ? name.slice(1) : name
-  return {
-    name,
-    once,
-    capture,
-    passive
-  }
-})
-
-export function createFnInvoker (fns: Function | Array<Function>, vm: ?Component): Function {
-  function invoker () {
-    const fns = invoker.fns
-    if (Array.isArray(fns)) {
-      const cloned = fns.slice()
-      for (let i = 0; i < cloned.length; i++) {
-        invokeWithErrorHandling(cloned[i], null, arguments, vm, `v-on handler`)
-      }
-    } else {
-      // return handler return value for single handlers
-      return invokeWithErrorHandling(fns, null, arguments, vm, `v-on handler`)
-    }
-  }
-  invoker.fns = fns
-  return invoker
-}
-
-export function updateListeners (
-  on: Object,
-  oldOn: Object,
-  add: Function,
-  remove: Function,
-  createOnceHandler: Function,
-  vm: Component
-) {
-  let name, def, cur, old, event
-  for (name in on) {
-    def = cur = on[name]
-    old = oldOn[name]
-    event = normalizeEvent(name)
-    /* istanbul ignore if */
-    if (__WEEX__ && isPlainObject(def)) {
-      cur = def.handler
-      event.params = def.params
-    }
-    if (isUndef(cur)) {
-      process.env.NODE_ENV !== '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, vm)
-      }
-      if (isTrue(event.once)) {
-        cur = on[name] = createOnceHandler(event.name, cur, event.capture)
-      }
-      add(event.name, cur, event.capture, event.passive, event.params)
-    } else if (cur !== old) {
-      old.fns = cur
-      on[name] = old
-    }
-  }
-  for (name in oldOn) {
-    if (isUndef(on[name])) {
-      event = normalizeEvent(name)
-      remove(event.name, oldOn[name], event.capture)
-    }
-  }
-}
diff --git a/1.Vue/src/core/vdom/modules/directives.js b/1.Vue/src/core/vdom/modules/directives.js
deleted file mode 100644
index ed76c62..0000000
--- a/1.Vue/src/core/vdom/modules/directives.js
+++ /dev/null
@@ -1,120 +0,0 @@
-/* @flow */
-
-import { emptyNode } from 'core/vdom/patch'
-import { resolveAsset, handleError } from 'core/util/index'
-import { mergeVNodeHook } from 'core/vdom/helpers/index'
-
-export default {
-  create: updateDirectives,
-  update: updateDirectives,
-  destroy: function unbindDirectives (vnode: VNodeWithData) {
-    updateDirectives(vnode, emptyNode)
-  }
-}
-
-function updateDirectives (oldVnode: VNodeWithData, vnode: VNodeWithData) {
-  if (oldVnode.data.directives || vnode.data.directives) {
-    _update(oldVnode, vnode)
-  }
-}
-
-function _update (oldVnode, vnode) {
-  const isCreate = oldVnode === emptyNode
-  const isDestroy = vnode === emptyNode
-  const oldDirs = normalizeDirectives(oldVnode.data.directives, oldVnode.context)
-  const newDirs = normalizeDirectives(vnode.data.directives, vnode.context)
-
-  const dirsWithInsert = []
-  const dirsWithPostpatch = []
-
-  let key, oldDir, dir
-  for (key in newDirs) {
-    oldDir = oldDirs[key]
-    dir = newDirs[key]
-    if (!oldDir) {
-      // new directive, bind
-      callHook(dir, 'bind', vnode, oldVnode)
-      if (dir.def && dir.def.inserted) {
-        dirsWithInsert.push(dir)
-      }
-    } else {
-      // existing directive, update
-      dir.oldValue = oldDir.value
-      dir.oldArg = oldDir.arg
-      callHook(dir, 'update', vnode, oldVnode)
-      if (dir.def && dir.def.componentUpdated) {
-        dirsWithPostpatch.push(dir)
-      }
-    }
-  }
-
-  if (dirsWithInsert.length) {
-    const callInsert = () => {
-      for (let i = 0; i < dirsWithInsert.length; i++) {
-        callHook(dirsWithInsert[i], 'inserted', vnode, oldVnode)
-      }
-    }
-    if (isCreate) {
-      mergeVNodeHook(vnode, 'insert', callInsert)
-    } else {
-      callInsert()
-    }
-  }
-
-  if (dirsWithPostpatch.length) {
-    mergeVNodeHook(vnode, 'postpatch', () => {
-      for (let i = 0; i < dirsWithPostpatch.length; i++) {
-        callHook(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode)
-      }
-    })
-  }
-
-  if (!isCreate) {
-    for (key in oldDirs) {
-      if (!newDirs[key]) {
-        // no longer present, unbind
-        callHook(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy)
-      }
-    }
-  }
-}
-
-const emptyModifiers = Object.create(null)
-
-function normalizeDirectives (
-  dirs: ?Array<VNodeDirective>,
-  vm: Component
-): { [key: string]: VNodeDirective } {
-  const res = Object.create(null)
-  if (!dirs) {
-    // $flow-disable-line
-    return res
-  }
-  let i, dir
-  for (i = 0; i < dirs.length; i++) {
-    dir = dirs[i]
-    if (!dir.modifiers) {
-      // $flow-disable-line
-      dir.modifiers = emptyModifiers
-    }
-    res[getRawDirName(dir)] = dir
-    dir.def = resolveAsset(vm.$options, 'directives', dir.name, true)
-  }
-  // $flow-disable-line
-  return res
-}
-
-function getRawDirName (dir: VNodeDirective): string {
-  return dir.rawName || `${dir.name}.${Object.keys(dir.modifiers || {}).join('.')}`
-}
-
-function callHook (dir, hook, vnode, oldVnode, isDestroy) {
-  const fn = dir.def && dir.def[hook]
-  if (fn) {
-    try {
-      fn(vnode.elm, dir, vnode, oldVnode, isDestroy)
-    } catch (e) {
-      handleError(e, vnode.context, `directive ${dir.name} ${hook} hook`)
-    }
-  }
-}
diff --git a/1.Vue/src/core/vdom/modules/index.js b/1.Vue/src/core/vdom/modules/index.js
deleted file mode 100644
index 727c864..0000000
--- a/1.Vue/src/core/vdom/modules/index.js
+++ /dev/null
@@ -1,7 +0,0 @@
-import directives from './directives'
-import ref from './ref'
-
-export default [
-  ref,
-  directives
-]
diff --git a/1.Vue/src/core/vdom/modules/ref.js b/1.Vue/src/core/vdom/modules/ref.js
deleted file mode 100644
index aa9bdcf..0000000
--- a/1.Vue/src/core/vdom/modules/ref.js
+++ /dev/null
@@ -1,45 +0,0 @@
-/* @flow */
-
-import { remove, isDef } from 'shared/util'
-
-export default {
-  create (_: any, vnode: VNodeWithData) {
-    registerRef(vnode)
-  },
-  update (oldVnode: VNodeWithData, vnode: VNodeWithData) {
-    if (oldVnode.data.ref !== vnode.data.ref) {
-      registerRef(oldVnode, true)
-      registerRef(vnode)
-    }
-  },
-  destroy (vnode: VNodeWithData) {
-    registerRef(vnode, true)
-  }
-}
-
-export function registerRef (vnode: VNodeWithData, isRemoval: ?boolean) {
-  const key = vnode.data.ref
-  if (!isDef(key)) return
-
-  const vm = vnode.context
-  const ref = vnode.componentInstance || vnode.elm
-  const refs = vm.$refs
-  if (isRemoval) {
-    if (Array.isArray(refs[key])) {
-      remove(refs[key], ref)
-    } else if (refs[key] === ref) {
-      refs[key] = undefined
-    }
-  } else {
-    if (vnode.data.refInFor) {
-      if (!Array.isArray(refs[key])) {
-        refs[key] = [ref]
-      } else if (refs[key].indexOf(ref) < 0) {
-        // $flow-disable-line
-        refs[key].push(ref)
-      }
-    } else {
-      refs[key] = ref
-    }
-  }
-}
diff --git a/1.Vue/src/core/vdom/patch.js b/1.Vue/src/core/vdom/patch.js
deleted file mode 100644
index 9746bb7..0000000
--- a/1.Vue/src/core/vdom/patch.js
+++ /dev/null
@@ -1,803 +0,0 @@
-/**
- * Virtual DOM patching algorithm based on Snabbdom by
- * Simon Friis Vindum (@paldepind)
- * Licensed under the MIT License
- * https://github.com/paldepind/snabbdom/blob/master/LICENSE
- *
- * modified by Evan You (@yyx990803)
- *
- * Not type-checking this because this file is perf-critical and the cost
- * of making flow understand it is not worth it.
- */
-
-import VNode, { cloneVNode } from './vnode'
-import config from '../config'
-import { SSR_ATTR } from 'shared/constants'
-import { registerRef } from './modules/ref'
-import { traverse } from '../observer/traverse'
-import { activeInstance } from '../instance/lifecycle'
-import { isTextInputType } from 'web/util/element'
-
-import {
-  warn,
-  isDef,
-  isUndef,
-  isTrue,
-  makeMap,
-  isRegExp,
-  isPrimitive
-} from '../util/index'
-
-export const emptyNode = new VNode('', {}, [])
-
-const hooks = ['create', 'activate', 'update', 'remove', 'destroy']
-
-function sameVnode (a, b) {
-  return (
-    a.key === b.key && (
-      (
-        a.tag === b.tag &&
-        a.isComment === b.isComment &&
-        isDef(a.data) === isDef(b.data) &&
-        sameInputType(a, b)
-      ) || (
-        isTrue(a.isAsyncPlaceholder) &&
-        a.asyncFactory === b.asyncFactory &&
-        isUndef(b.asyncFactory.error)
-      )
-    )
-  )
-}
-
-function sameInputType (a, b) {
-  if (a.tag !== 'input') return true
-  let i
-  const typeA = isDef(i = a.data) && isDef(i = i.attrs) && i.type
-  const typeB = isDef(i = b.data) && isDef(i = i.attrs) && i.type
-  return typeA === typeB || isTextInputType(typeA) && isTextInputType(typeB)
-}
-
-function createKeyToOldIdx (children, beginIdx, endIdx) {
-  let i, key
-  const map = {}
-  for (i = beginIdx; i <= endIdx; ++i) {
-    key = children[i].key
-    if (isDef(key)) map[key] = i
-  }
-  return map
-}
-
-export function createPatchFunction (backend) {
-  let i, j
-  const cbs = {}
-
-  const { modules, nodeOps } = backend
-
-  for (i = 0; i < hooks.length; ++i) {
-    cbs[hooks[i]] = []
-    for (j = 0; j < modules.length; ++j) {
-      if (isDef(modules[j][hooks[i]])) {
-        cbs[hooks[i]].push(modules[j][hooks[i]])
-      }
-    }
-  }
-
-  function emptyNodeAt (elm) {
-    return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm)
-  }
-
-  function createRmCb (childElm, listeners) {
-    function remove () {
-      if (--remove.listeners === 0) {
-        removeNode(childElm)
-      }
-    }
-    remove.listeners = listeners
-    return remove
-  }
-
-  function removeNode (el) {
-    const parent = nodeOps.parentNode(el)
-    // element may have already been removed due to v-html / v-text
-    if (isDef(parent)) {
-      nodeOps.removeChild(parent, el)
-    }
-  }
-
-  function isUnknownElement (vnode, inVPre) {
-    return (
-      !inVPre &&
-      !vnode.ns &&
-      !(
-        config.ignoredElements.length &&
-        config.ignoredElements.some(ignore => {
-          return isRegExp(ignore)
-            ? ignore.test(vnode.tag)
-            : ignore === vnode.tag
-        })
-      ) &&
-      config.isUnknownElement(vnode.tag)
-    )
-  }
-
-  let creatingElmInVPre = 0
-
-  function createElm (
-    vnode,
-    insertedVnodeQueue,
-    parentElm,
-    refElm,
-    nested,
-    ownerArray,
-    index
-  ) {
-    if (isDef(vnode.elm) && isDef(ownerArray)) {
-      // This vnode was used in a previous render!
-      // now it's used as a new node, overwriting its elm would cause
-      // potential patch errors down the road when it's used as an insertion
-      // reference node. Instead, we clone the node on-demand before creating
-      // associated DOM element for it.
-      vnode = ownerArray[index] = cloneVNode(vnode)
-    }
-
-    vnode.isRootInsert = !nested // for transition enter check
-    if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {
-      return
-    }
-
-    const data = vnode.data
-    const children = vnode.children
-    const tag = vnode.tag
-    if (isDef(tag)) {
-      if (process.env.NODE_ENV !== 'production') {
-        if (data && data.pre) {
-          creatingElmInVPre++
-        }
-        if (isUnknownElement(vnode, creatingElmInVPre)) {
-          warn(
-            'Unknown custom element: <' + tag + '> - did you ' +
-            'register the component correctly? For recursive components, ' +
-            'make sure to provide the "name" option.',
-            vnode.context
-          )
-        }
-      }
-
-      vnode.elm = vnode.ns
-        ? nodeOps.createElementNS(vnode.ns, tag)
-        : nodeOps.createElement(tag, vnode)
-      setScope(vnode)
-
-      /* istanbul ignore if */
-      if (__WEEX__) {
-        // in Weex, the default insertion order is parent-first.
-        // List items can be optimized to use children-first insertion
-        // with append="tree".
-        const appendAsTree = isDef(data) && isTrue(data.appendAsTree)
-        if (!appendAsTree) {
-          if (isDef(data)) {
-            invokeCreateHooks(vnode, insertedVnodeQueue)
-          }
-          insert(parentElm, vnode.elm, refElm)
-        }
-        createChildren(vnode, children, insertedVnodeQueue)
-        if (appendAsTree) {
-          if (isDef(data)) {
-            invokeCreateHooks(vnode, insertedVnodeQueue)
-          }
-          insert(parentElm, vnode.elm, refElm)
-        }
-      } else {
-        createChildren(vnode, children, insertedVnodeQueue)
-        if (isDef(data)) {
-          invokeCreateHooks(vnode, insertedVnodeQueue)
-        }
-        insert(parentElm, vnode.elm, refElm)
-      }
-
-      if (process.env.NODE_ENV !== 'production' && data && data.pre) {
-        creatingElmInVPre--
-      }
-    } else if (isTrue(vnode.isComment)) {
-      vnode.elm = nodeOps.createComment(vnode.text)
-      insert(parentElm, vnode.elm, refElm)
-    } else {
-      vnode.elm = nodeOps.createTextNode(vnode.text)
-      insert(parentElm, vnode.elm, refElm)
-    }
-  }
-
-  function createComponent (vnode, insertedVnodeQueue, parentElm, refElm) {
-    let i = vnode.data
-    if (isDef(i)) {
-      const isReactivated = isDef(vnode.componentInstance) && i.keepAlive
-      if (isDef(i = i.hook) && isDef(i = i.init)) {
-        i(vnode, false /* hydrating */)
-      }
-      // after calling the init hook, if the vnode is a child component
-      // it should've created a child instance and mounted it. the child
-      // component also has set the placeholder vnode's elm.
-      // in that case we can just return the element and be done.
-      if (isDef(vnode.componentInstance)) {
-        initComponent(vnode, insertedVnodeQueue)
-        insert(parentElm, vnode.elm, refElm)
-        if (isTrue(isReactivated)) {
-          reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm)
-        }
-        return true
-      }
-    }
-  }
-
-  function initComponent (vnode, insertedVnodeQueue) {
-    if (isDef(vnode.data.pendingInsert)) {
-      insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert)
-      vnode.data.pendingInsert = null
-    }
-    vnode.elm = vnode.componentInstance.$el
-    if (isPatchable(vnode)) {
-      invokeCreateHooks(vnode, insertedVnodeQueue)
-      setScope(vnode)
-    } else {
-      // empty component root.
-      // skip all element-related modules except for ref (#3455)
-      registerRef(vnode)
-      // make sure to invoke the insert hook
-      insertedVnodeQueue.push(vnode)
-    }
-  }
-
-  function reactivateComponent (vnode, insertedVnodeQueue, parentElm, refElm) {
-    let i
-    // hack for #4339: a reactivated component with inner transition
-    // does not trigger because the inner node's created hooks are not called
-    // again. It's not ideal to involve module-specific logic in here but
-    // there doesn't seem to be a better way to do it.
-    let innerNode = vnode
-    while (innerNode.componentInstance) {
-      innerNode = innerNode.componentInstance._vnode
-      if (isDef(i = innerNode.data) && isDef(i = i.transition)) {
-        for (i = 0; i < cbs.activate.length; ++i) {
-          cbs.activate[i](emptyNode, innerNode)
-        }
-        insertedVnodeQueue.push(innerNode)
-        break
-      }
-    }
-    // unlike a newly created component,
-    // a reactivated keep-alive component doesn't insert itself
-    insert(parentElm, vnode.elm, refElm)
-  }
-
-  function insert (parent, elm, ref) {
-    if (isDef(parent)) {
-      if (isDef(ref)) {
-        if (nodeOps.parentNode(ref) === parent) {
-          nodeOps.insertBefore(parent, elm, ref)
-        }
-      } else {
-        nodeOps.appendChild(parent, elm)
-      }
-    }
-  }
-
-  function createChildren (vnode, children, insertedVnodeQueue) {
-    if (Array.isArray(children)) {
-      if (process.env.NODE_ENV !== 'production') {
-        checkDuplicateKeys(children)
-      }
-      for (let i = 0; i < children.length; ++i) {
-        createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i)
-      }
-    } else if (isPrimitive(vnode.text)) {
-      nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(String(vnode.text)))
-    }
-  }
-
-  function isPatchable (vnode) {
-    while (vnode.componentInstance) {
-      vnode = vnode.componentInstance._vnode
-    }
-    return isDef(vnode.tag)
-  }
-
-  function invokeCreateHooks (vnode, insertedVnodeQueue) {
-    for (let i = 0; i < cbs.create.length; ++i) {
-      cbs.create[i](emptyNode, vnode)
-    }
-    i = vnode.data.hook // Reuse variable
-    if (isDef(i)) {
-      if (isDef(i.create)) i.create(emptyNode, vnode)
-      if (isDef(i.insert)) insertedVnodeQueue.push(vnode)
-    }
-  }
-
-  // set scope id attribute for scoped CSS.
-  // this is implemented as a special case to avoid the overhead
-  // of going through the normal attribute patching process.
-  function setScope (vnode) {
-    let i
-    if (isDef(i = vnode.fnScopeId)) {
-      nodeOps.setStyleScope(vnode.elm, i)
-    } else {
-      let ancestor = vnode
-      while (ancestor) {
-        if (isDef(i = ancestor.context) && isDef(i = i.$options._scopeId)) {
-          nodeOps.setStyleScope(vnode.elm, i)
-        }
-        ancestor = ancestor.parent
-      }
-    }
-    // for slot content they should also get the scopeId from the host instance.
-    if (isDef(i = activeInstance) &&
-      i !== vnode.context &&
-      i !== vnode.fnContext &&
-      isDef(i = i.$options._scopeId)
-    ) {
-      nodeOps.setStyleScope(vnode.elm, i)
-    }
-  }
-
-  function addVnodes (parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {
-    for (; startIdx <= endIdx; ++startIdx) {
-      createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm, false, vnodes, startIdx)
-    }
-  }
-
-  function invokeDestroyHook (vnode) {
-    let i, j
-    const data = vnode.data
-    if (isDef(data)) {
-      if (isDef(i = data.hook) && isDef(i = i.destroy)) i(vnode)
-      for (i = 0; i < cbs.destroy.length; ++i) cbs.destroy[i](vnode)
-    }
-    if (isDef(i = vnode.children)) {
-      for (j = 0; j < vnode.children.length; ++j) {
-        invokeDestroyHook(vnode.children[j])
-      }
-    }
-  }
-
-  function removeVnodes (parentElm, vnodes, startIdx, endIdx) {
-    for (; startIdx <= endIdx; ++startIdx) {
-      const ch = vnodes[startIdx]
-      if (isDef(ch)) {
-        if (isDef(ch.tag)) {
-          removeAndInvokeRemoveHook(ch)
-          invokeDestroyHook(ch)
-        } else { // Text node
-          removeNode(ch.elm)
-        }
-      }
-    }
-  }
-
-  function removeAndInvokeRemoveHook (vnode, rm) {
-    if (isDef(rm) || isDef(vnode.data)) {
-      let i
-      const listeners = cbs.remove.length + 1
-      if (isDef(rm)) {
-        // we have a recursively passed down rm callback
-        // increase the listeners count
-        rm.listeners += listeners
-      } else {
-        // directly removing
-        rm = createRmCb(vnode.elm, listeners)
-      }
-      // recursively invoke hooks on child component root node
-      if (isDef(i = vnode.componentInstance) && isDef(i = i._vnode) && isDef(i.data)) {
-        removeAndInvokeRemoveHook(i, rm)
-      }
-      for (i = 0; i < cbs.remove.length; ++i) {
-        cbs.remove[i](vnode, rm)
-      }
-      if (isDef(i = vnode.data.hook) && isDef(i = i.remove)) {
-        i(vnode, rm)
-      } else {
-        rm()
-      }
-    } else {
-      removeNode(vnode.elm)
-    }
-  }
-
-  function updateChildren (parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
-    let oldStartIdx = 0
-    let newStartIdx = 0
-    let oldEndIdx = oldCh.length - 1
-    let oldStartVnode = oldCh[0]
-    let oldEndVnode = oldCh[oldEndIdx]
-    let newEndIdx = newCh.length - 1
-    let newStartVnode = newCh[0]
-    let newEndVnode = newCh[newEndIdx]
-    let oldKeyToIdx, idxInOld, vnodeToMove, refElm
-
-    // removeOnly is a special flag used only by <transition-group>
-    // to ensure removed elements stay in correct relative positions
-    // during leaving transitions
-    const canMove = !removeOnly
-
-    if (process.env.NODE_ENV !== 'production') {
-      checkDuplicateKeys(newCh)
-    }
-
-    while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
-      if (isUndef(oldStartVnode)) {
-        oldStartVnode = oldCh[++oldStartIdx] // Vnode has been moved left
-      } else if (isUndef(oldEndVnode)) {
-        oldEndVnode = oldCh[--oldEndIdx]
-      } else if (sameVnode(oldStartVnode, newStartVnode)) {
-        patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx)
-        oldStartVnode = oldCh[++oldStartIdx]
-        newStartVnode = newCh[++newStartIdx]
-      } else if (sameVnode(oldEndVnode, newEndVnode)) {
-        patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx)
-        oldEndVnode = oldCh[--oldEndIdx]
-        newEndVnode = newCh[--newEndIdx]
-      } else if (sameVnode(oldStartVnode, newEndVnode)) { // Vnode moved right
-        patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx)
-        canMove && nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm))
-        oldStartVnode = oldCh[++oldStartIdx]
-        newEndVnode = newCh[--newEndIdx]
-      } else if (sameVnode(oldEndVnode, newStartVnode)) { // Vnode moved left
-        patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx)
-        canMove && nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm)
-        oldEndVnode = oldCh[--oldEndIdx]
-        newStartVnode = newCh[++newStartIdx]
-      } else {
-        if (isUndef(oldKeyToIdx)) oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx)
-        idxInOld = isDef(newStartVnode.key)
-          ? oldKeyToIdx[newStartVnode.key]
-          : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx)
-        if (isUndef(idxInOld)) { // New element
-          createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx)
-        } else {
-          vnodeToMove = oldCh[idxInOld]
-          if (sameVnode(vnodeToMove, newStartVnode)) {
-            patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue, newCh, newStartIdx)
-            oldCh[idxInOld] = undefined
-            canMove && nodeOps.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm)
-          } else {
-            // same key but different element. treat as new element
-            createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx)
-          }
-        }
-        newStartVnode = newCh[++newStartIdx]
-      }
-    }
-    if (oldStartIdx > oldEndIdx) {
-      refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm
-      addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue)
-    } else if (newStartIdx > newEndIdx) {
-      removeVnodes(parentElm, oldCh, oldStartIdx, oldEndIdx)
-    }
-  }
-
-  function checkDuplicateKeys (children) {
-    const seenKeys = {}
-    for (let i = 0; i < children.length; i++) {
-      const vnode = children[i]
-      const key = vnode.key
-      if (isDef(key)) {
-        if (seenKeys[key]) {
-          warn(
-            `Duplicate keys detected: '${key}'. This may cause an update error.`,
-            vnode.context
-          )
-        } else {
-          seenKeys[key] = true
-        }
-      }
-    }
-  }
-
-  function findIdxInOld (node, oldCh, start, end) {
-    for (let i = start; i < end; i++) {
-      const c = oldCh[i]
-      if (isDef(c) && sameVnode(node, c)) return i
-    }
-  }
-
-  function patchVnode (
-    oldVnode,
-    vnode,
-    insertedVnodeQueue,
-    ownerArray,
-    index,
-    removeOnly
-  ) {
-    if (oldVnode === vnode) {
-      return
-    }
-
-    if (isDef(vnode.elm) && isDef(ownerArray)) {
-      // clone reused vnode
-      vnode = ownerArray[index] = cloneVNode(vnode)
-    }
-
-    const elm = vnode.elm = oldVnode.elm
-
-    if (isTrue(oldVnode.isAsyncPlaceholder)) {
-      if (isDef(vnode.asyncFactory.resolved)) {
-        hydrate(oldVnode.elm, vnode, insertedVnodeQueue)
-      } else {
-        vnode.isAsyncPlaceholder = true
-      }
-      return
-    }
-
-    // reuse element for static trees.
-    // note we only do this if the vnode is cloned -
-    // if the new node is not cloned it means the render functions have been
-    // reset by the hot-reload-api and we need to do a proper re-render.
-    if (isTrue(vnode.isStatic) &&
-      isTrue(oldVnode.isStatic) &&
-      vnode.key === oldVnode.key &&
-      (isTrue(vnode.isCloned) || isTrue(vnode.isOnce))
-    ) {
-      vnode.componentInstance = oldVnode.componentInstance
-      return
-    }
-
-    let i
-    const data = vnode.data
-    if (isDef(data) && isDef(i = data.hook) && isDef(i = i.prepatch)) {
-      i(oldVnode, vnode)
-    }
-
-    const oldCh = oldVnode.children
-    const ch = vnode.children
-    if (isDef(data) && isPatchable(vnode)) {
-      for (i = 0; i < cbs.update.length; ++i) cbs.update[i](oldVnode, vnode)
-      if (isDef(i = data.hook) && isDef(i = i.update)) i(oldVnode, vnode)
-    }
-    if (isUndef(vnode.text)) {
-      if (isDef(oldCh) && isDef(ch)) {
-        if (oldCh !== ch) updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly)
-      } else if (isDef(ch)) {
-        if (process.env.NODE_ENV !== 'production') {
-          checkDuplicateKeys(ch)
-        }
-        if (isDef(oldVnode.text)) nodeOps.setTextContent(elm, '')
-        addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue)
-      } else if (isDef(oldCh)) {
-        removeVnodes(elm, oldCh, 0, oldCh.length - 1)
-      } else if (isDef(oldVnode.text)) {
-        nodeOps.setTextContent(elm, '')
-      }
-    } else if (oldVnode.text !== vnode.text) {
-      nodeOps.setTextContent(elm, vnode.text)
-    }
-    if (isDef(data)) {
-      if (isDef(i = data.hook) && isDef(i = i.postpatch)) i(oldVnode, vnode)
-    }
-  }
-
-  function invokeInsertHook (vnode, queue, initial) {
-    // delay insert hooks for component root nodes, invoke them after the
-    // element is really inserted
-    if (isTrue(initial) && isDef(vnode.parent)) {
-      vnode.parent.data.pendingInsert = queue
-    } else {
-      for (let i = 0; i < queue.length; ++i) {
-        queue[i].data.hook.insert(queue[i])
-      }
-    }
-  }
-
-  let hydrationBailed = false
-  // list of modules that can skip create hook during hydration because they
-  // are already rendered on the client or has no need for initialization
-  // Note: style is excluded because it relies on initial clone for future
-  // deep updates (#7063).
-  const isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key')
-
-  // Note: this is a browser-only function so we can assume elms are DOM nodes.
-  function hydrate (elm, vnode, insertedVnodeQueue, inVPre) {
-    let i
-    const { tag, data, children } = vnode
-    inVPre = inVPre || (data && data.pre)
-    vnode.elm = elm
-
-    if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
-      vnode.isAsyncPlaceholder = true
-      return true
-    }
-    // assert node match
-    if (process.env.NODE_ENV !== 'production') {
-      if (!assertNodeMatch(elm, vnode, inVPre)) {
-        return false
-      }
-    }
-    if (isDef(data)) {
-      if (isDef(i = data.hook) && isDef(i = i.init)) i(vnode, true /* hydrating */)
-      if (isDef(i = vnode.componentInstance)) {
-        // child component. it should have hydrated its own tree.
-        initComponent(vnode, insertedVnodeQueue)
-        return true
-      }
-    }
-    if (isDef(tag)) {
-      if (isDef(children)) {
-        // empty element, allow client to pick up and populate children
-        if (!elm.hasChildNodes()) {
-          createChildren(vnode, children, insertedVnodeQueue)
-        } else {
-          // v-html and domProps: innerHTML
-          if (isDef(i = data) && isDef(i = i.domProps) && isDef(i = i.innerHTML)) {
-            if (i !== elm.innerHTML) {
-              /* istanbul ignore if */
-              if (process.env.NODE_ENV !== 'production' &&
-                typeof console !== 'undefined' &&
-                !hydrationBailed
-              ) {
-                hydrationBailed = true
-                console.warn('Parent: ', elm)
-                console.warn('server innerHTML: ', i)
-                console.warn('client innerHTML: ', elm.innerHTML)
-              }
-              return false
-            }
-          } else {
-            // iterate and compare children lists
-            let childrenMatch = true
-            let childNode = elm.firstChild
-            for (let i = 0; i < children.length; i++) {
-              if (!childNode || !hydrate(childNode, children[i], insertedVnodeQueue, inVPre)) {
-                childrenMatch = false
-                break
-              }
-              childNode = childNode.nextSibling
-            }
-            // if childNode is not null, it means the actual childNodes list is
-            // longer than the virtual children list.
-            if (!childrenMatch || childNode) {
-              /* istanbul ignore if */
-              if (process.env.NODE_ENV !== 'production' &&
-                typeof console !== 'undefined' &&
-                !hydrationBailed
-              ) {
-                hydrationBailed = true
-                console.warn('Parent: ', elm)
-                console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children)
-              }
-              return false
-            }
-          }
-        }
-      }
-      if (isDef(data)) {
-        let fullInvoke = false
-        for (const key in data) {
-          if (!isRenderedModule(key)) {
-            fullInvoke = true
-            invokeCreateHooks(vnode, insertedVnodeQueue)
-            break
-          }
-        }
-        if (!fullInvoke && data['class']) {
-          // ensure collecting deps for deep class bindings for future updates
-          traverse(data['class'])
-        }
-      }
-    } else if (elm.data !== vnode.text) {
-      elm.data = vnode.text
-    }
-    return true
-  }
-
-  function assertNodeMatch (node, vnode, inVPre) {
-    if (isDef(vnode.tag)) {
-      return vnode.tag.indexOf('vue-component') === 0 || (
-        !isUnknownElement(vnode, inVPre) &&
-        vnode.tag.toLowerCase() === (node.tagName && node.tagName.toLowerCase())
-      )
-    } else {
-      return node.nodeType === (vnode.isComment ? 8 : 3)
-    }
-  }
-
-  return function patch (oldVnode, vnode, hydrating, removeOnly) {
-    if (isUndef(vnode)) {
-      if (isDef(oldVnode)) invokeDestroyHook(oldVnode)
-      return
-    }
-
-    let isInitialPatch = false
-    const insertedVnodeQueue = []
-
-    if (isUndef(oldVnode)) {
-      // empty mount (likely as component), create new root element
-      isInitialPatch = true
-      createElm(vnode, insertedVnodeQueue)
-    } else {
-      const isRealElement = isDef(oldVnode.nodeType)
-      if (!isRealElement && sameVnode(oldVnode, vnode)) {
-        // patch existing root node
-        patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly)
-      } else {
-        if (isRealElement) {
-          // mounting to a real element
-          // check if this is server-rendered content and if we can perform
-          // a successful hydration.
-          if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR)) {
-            oldVnode.removeAttribute(SSR_ATTR)
-            hydrating = true
-          }
-          if (isTrue(hydrating)) {
-            if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {
-              invokeInsertHook(vnode, insertedVnodeQueue, true)
-              return oldVnode
-            } else if (process.env.NODE_ENV !== 'production') {
-              warn(
-                'The client-side rendered virtual DOM tree is not matching ' +
-                'server-rendered content. This is likely caused by incorrect ' +
-                'HTML markup, for example nesting block-level elements inside ' +
-                '<p>, or missing <tbody>. 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
-        const oldElm = oldVnode.elm
-        const parentElm = nodeOps.parentNode(oldElm)
-
-        // create new node
-        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,
-          nodeOps.nextSibling(oldElm)
-        )
-
-        // update parent placeholder node element, recursively
-        if (isDef(vnode.parent)) {
-          let ancestor = vnode.parent
-          const patchable = isPatchable(vnode)
-          while (ancestor) {
-            for (let i = 0; i < cbs.destroy.length; ++i) {
-              cbs.destroy[i](ancestor)
-            }
-            ancestor.elm = vnode.elm
-            if (patchable) {
-              for (let i = 0; i < cbs.create.length; ++i) {
-                cbs.create[i](emptyNode, ancestor)
-              }
-              // #6513
-              // invoke insert hooks that may have been merged by create hooks.
-              // e.g. for directives that uses the "inserted" hook.
-              const insert = ancestor.data.hook.insert
-              if (insert.merged) {
-                // start at index 1 to avoid re-invoking component mounted hook
-                for (let i = 1; i < insert.fns.length; i++) {
-                  insert.fns[i]()
-                }
-              }
-            } else {
-              registerRef(ancestor)
-            }
-            ancestor = ancestor.parent
-          }
-        }
-
-        // destroy old node
-        if (isDef(parentElm)) {
-          removeVnodes(parentElm, [oldVnode], 0, 0)
-        } else if (isDef(oldVnode.tag)) {
-          invokeDestroyHook(oldVnode)
-        }
-      }
-    }
-
-    invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch)
-    return vnode.elm
-  }
-}
diff --git a/1.Vue/src/core/vdom/vnode.js b/1.Vue/src/core/vdom/vnode.js
deleted file mode 100644
index bdc17e9..0000000
--- a/1.Vue/src/core/vdom/vnode.js
+++ /dev/null
@@ -1,113 +0,0 @@
-/* @flow */
-
-export default class VNode {
-  tag: string | void;
-  data: VNodeData | void;
-  children: ?Array<VNode>;
-  text: string | void;
-  elm: Node | void;
-  ns: string | void;
-  context: Component | void; // rendered in this component's scope
-  key: string | number | void;
-  componentOptions: VNodeComponentOptions | void;
-  componentInstance: Component | void; // component instance
-  parent: VNode | void; // component placeholder node
-
-  // strictly internal
-  raw: boolean; // contains raw HTML? (server only)
-  isStatic: boolean; // hoisted static node
-  isRootInsert: boolean; // necessary for enter transition check
-  isComment: boolean; // empty comment placeholder?
-  isCloned: boolean; // is a cloned node?
-  isOnce: boolean; // is a v-once node?
-  asyncFactory: Function | void; // async component factory function
-  asyncMeta: Object | void;
-  isAsyncPlaceholder: boolean;
-  ssrContext: Object | void;
-  fnContext: Component | void; // real context vm for functional nodes
-  fnOptions: ?ComponentOptions; // for SSR caching
-  devtoolsMeta: ?Object; // used to store functional render context for devtools
-  fnScopeId: ?string; // functional scope id support
-
-  constructor (
-    tag?: string,
-    data?: VNodeData,
-    children?: ?Array<VNode>,
-    text?: string,
-    elm?: Node,
-    context?: Component,
-    componentOptions?: VNodeComponentOptions,
-    asyncFactory?: Function
-  ) {
-    this.tag = tag
-    this.data = data
-    this.children = children
-    this.text = text
-    this.elm = elm
-    this.ns = undefined
-    this.context = context
-    this.fnContext = undefined
-    this.fnOptions = undefined
-    this.fnScopeId = 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
-  }
-
-  // DEPRECATED: alias for componentInstance for backwards compat.
-  /* istanbul ignore next */
-  get child (): Component | void {
-    return this.componentInstance
-  }
-}
-
-export const createEmptyVNode = (text: string = '') => {
-  const node = new VNode()
-  node.text = text
-  node.isComment = true
-  return node
-}
-
-export function createTextVNode (val: string | number) {
-  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.
-export function cloneVNode (vnode: VNode): VNode {
-  const cloned = new VNode(
-    vnode.tag,
-    vnode.data,
-    // #7975
-    // clone children array to avoid mutating original in case of cloning
-    // a child.
-    vnode.children && vnode.children.slice(),
-    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.fnContext = vnode.fnContext
-  cloned.fnOptions = vnode.fnOptions
-  cloned.fnScopeId = vnode.fnScopeId
-  cloned.asyncMeta = vnode.asyncMeta
-  cloned.isCloned = true
-  return cloned
-}
diff --git a/1.Vue/src/platforms/web/compiler/directives/html.js b/1.Vue/src/platforms/web/compiler/directives/html.js
deleted file mode 100644
index a4b7062..0000000
--- a/1.Vue/src/platforms/web/compiler/directives/html.js
+++ /dev/null
@@ -1,9 +0,0 @@
-/* @flow */
-
-import { addProp } from 'compiler/helpers'
-
-export default function html (el: ASTElement, dir: ASTDirective) {
-  if (dir.value) {
-    addProp(el, 'innerHTML', `_s(${dir.value})`, dir)
-  }
-}
diff --git a/1.Vue/src/platforms/web/compiler/directives/index.js b/1.Vue/src/platforms/web/compiler/directives/index.js
deleted file mode 100644
index 0955b51..0000000
--- a/1.Vue/src/platforms/web/compiler/directives/index.js
+++ /dev/null
@@ -1,9 +0,0 @@
-import model from './model'
-import text from './text'
-import html from './html'
-
-export default {
-  model,
-  text,
-  html
-}
diff --git a/1.Vue/src/platforms/web/compiler/directives/model.js b/1.Vue/src/platforms/web/compiler/directives/model.js
deleted file mode 100644
index a420961..0000000
--- a/1.Vue/src/platforms/web/compiler/directives/model.js
+++ /dev/null
@@ -1,175 +0,0 @@
-/* @flow */
-
-import config from 'core/config'
-import { addHandler, addProp, getBindingAttr } from 'compiler/helpers'
-import { genComponentModel, genAssignmentCode } from 'compiler/directives/model'
-
-let warn
-
-// in some cases, the event used has to be determined at runtime
-// so we used some reserved tokens during compile.
-export const RANGE_TOKEN = '__r'
-export const CHECKBOX_RADIO_TOKEN = '__c'
-
-export default function model (
-  el: ASTElement,
-  dir: ASTDirective,
-  _warn: Function
-): ?boolean {
-  warn = _warn
-  const value = dir.value
-  const modifiers = dir.modifiers
-  const tag = el.tag
-  const type = el.attrsMap.type
-
-  if (process.env.NODE_ENV !== 'production') {
-    // inputs with type="file" are read only and setting the input's
-    // value will throw an error.
-    if (tag === 'input' && type === 'file') {
-      warn(
-        `<${el.tag} v-model="${value}" type="file">:\n` +
-        `File inputs are read only. Use a v-on:change listener instead.`,
-        el.rawAttrsMap['v-model']
-      )
-    }
-  }
-
-  if (el.component) {
-    genComponentModel(el, value, modifiers)
-    // component v-model doesn't need extra runtime
-    return false
-  } else 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 if (process.env.NODE_ENV !== 'production') {
-    warn(
-      `<${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.',
-      el.rawAttrsMap['v-model']
-    )
-  }
-
-  // ensure runtime directive metadata
-  return true
-}
-
-function genCheckboxModel (
-  el: ASTElement,
-  value: string,
-  modifiers: ?ASTModifiers
-) {
-  const number = modifiers && modifiers.number
-  const valueBinding = getBindingAttr(el, 'value') || 'null'
-  const trueValueBinding = getBindingAttr(el, 'true-value') || 'true'
-  const falseValueBinding = getBindingAttr(el, 'false-value') || 'false'
-  addProp(el, 'checked',
-    `Array.isArray(${value})` +
-    `?_i(${value},${valueBinding})>-1` + (
-      trueValueBinding === 'true'
-        ? `:(${value})`
-        : `:_q(${value},${trueValueBinding})`
-    )
-  )
-  addHandler(el, 'change',
-    `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($$el.checked){$$i<0&&(${genAssignmentCode(value, '$$a.concat([$$v])')})}` +
-      `else{$$i>-1&&(${genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')})}` +
-    `}else{${genAssignmentCode(value, '$$c')}}`,
-    null, true
-  )
-}
-
-function genRadioModel (
-  el: ASTElement,
-  value: string,
-  modifiers: ?ASTModifiers
-) {
-  const number = modifiers && modifiers.number
-  let valueBinding = getBindingAttr(el, 'value') || 'null'
-  valueBinding = number ? `_n(${valueBinding})` : valueBinding
-  addProp(el, 'checked', `_q(${value},${valueBinding})`)
-  addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true)
-}
-
-function genSelect (
-  el: ASTElement,
-  value: string,
-  modifiers: ?ASTModifiers
-) {
-  const number = modifiers && modifiers.number
-  const 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'}})`
-
-  const assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]'
-  let code = `var $$selectedVal = ${selectedVal};`
-  code = `${code} ${genAssignmentCode(value, assignment)}`
-  addHandler(el, 'change', code, null, true)
-}
-
-function genDefaultModel (
-  el: ASTElement,
-  value: string,
-  modifiers: ?ASTModifiers
-): ?boolean {
-  const type = el.attrsMap.type
-
-  // warn if v-bind:value conflicts with v-model
-  // except for inputs with v-bind:type
-  if (process.env.NODE_ENV !== 'production') {
-    const value = el.attrsMap['v-bind:value'] || el.attrsMap[':value']
-    const typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type']
-    if (value && !typeBinding) {
-      const binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value'
-      warn(
-        `${binding}="${value}" conflicts with v-model on the same element ` +
-        'because the latter already expands to a value binding internally',
-        el.rawAttrsMap[binding]
-      )
-    }
-  }
-
-  const { lazy, number, trim } = modifiers || {}
-  const needCompositionGuard = !lazy && type !== 'range'
-  const event = lazy
-    ? 'change'
-    : type === 'range'
-      ? RANGE_TOKEN
-      : 'input'
-
-  let valueExpression = '$event.target.value'
-  if (trim) {
-    valueExpression = `$event.target.value.trim()`
-  }
-  if (number) {
-    valueExpression = `_n(${valueExpression})`
-  }
-
-  let 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) {
-    addHandler(el, 'blur', '$forceUpdate()')
-  }
-}
diff --git a/1.Vue/src/platforms/web/compiler/directives/text.js b/1.Vue/src/platforms/web/compiler/directives/text.js
deleted file mode 100644
index c434d3e..0000000
--- a/1.Vue/src/platforms/web/compiler/directives/text.js
+++ /dev/null
@@ -1,9 +0,0 @@
-/* @flow */
-
-import { addProp } from 'compiler/helpers'
-
-export default function text (el: ASTElement, dir: ASTDirective) {
-  if (dir.value) {
-    addProp(el, 'textContent', `_s(${dir.value})`, dir)
-  }
-}
diff --git a/1.Vue/src/platforms/web/compiler/index.js b/1.Vue/src/platforms/web/compiler/index.js
deleted file mode 100644
index 7ace093..0000000
--- a/1.Vue/src/platforms/web/compiler/index.js
+++ /dev/null
@@ -1,8 +0,0 @@
-/* @flow */
-
-import { baseOptions } from './options'
-import { createCompiler } from 'compiler/index'
-
-const { compile, compileToFunctions } = createCompiler(baseOptions)
-
-export { compile, compileToFunctions }
diff --git a/1.Vue/src/platforms/web/compiler/modules/class.js b/1.Vue/src/platforms/web/compiler/modules/class.js
deleted file mode 100644
index dcb5a22..0000000
--- a/1.Vue/src/platforms/web/compiler/modules/class.js
+++ /dev/null
@@ -1,49 +0,0 @@
-/* @flow */
-
-import { parseText } from 'compiler/parser/text-parser'
-import {
-  getAndRemoveAttr,
-  getBindingAttr,
-  baseWarn
-} from 'compiler/helpers'
-
-function transformNode (el: ASTElement, options: CompilerOptions) {
-  const warn = options.warn || baseWarn
-  const staticClass = getAndRemoveAttr(el, 'class')
-  if (process.env.NODE_ENV !== 'production' && staticClass) {
-    const res = parseText(staticClass, options.delimiters)
-    if (res) {
-      warn(
-        `class="${staticClass}": ` +
-        'Interpolation inside attributes has been removed. ' +
-        'Use v-bind or the colon shorthand instead. For example, ' +
-        'instead of <div class="{{ val }}">, use <div :class="val">.',
-        el.rawAttrsMap['class']
-      )
-    }
-  }
-  if (staticClass) {
-    el.staticClass = JSON.stringify(staticClass)
-  }
-  const classBinding = getBindingAttr(el, 'class', false /* getStatic */)
-  if (classBinding) {
-    el.classBinding = classBinding
-  }
-}
-
-function genData (el: ASTElement): string {
-  let data = ''
-  if (el.staticClass) {
-    data += `staticClass:${el.staticClass},`
-  }
-  if (el.classBinding) {
-    data += `class:${el.classBinding},`
-  }
-  return data
-}
-
-export default {
-  staticKeys: ['staticClass'],
-  transformNode,
-  genData
-}
diff --git a/1.Vue/src/platforms/web/compiler/modules/index.js b/1.Vue/src/platforms/web/compiler/modules/index.js
deleted file mode 100644
index 29114a5..0000000
--- a/1.Vue/src/platforms/web/compiler/modules/index.js
+++ /dev/null
@@ -1,9 +0,0 @@
-import klass from './class'
-import style from './style'
-import model from './model'
-
-export default [
-  klass,
-  style,
-  model
-]
diff --git a/1.Vue/src/platforms/web/compiler/modules/model.js b/1.Vue/src/platforms/web/compiler/modules/model.js
deleted file mode 100644
index 8d784fe..0000000
--- a/1.Vue/src/platforms/web/compiler/modules/model.js
+++ /dev/null
@@ -1,94 +0,0 @@
-/* @flow */
-
-/**
- * Expand input[v-model] with dyanmic type bindings into v-if-else chains
- * Turn this:
- *   <input v-model="data[type]" :type="type">
- * into this:
- *   <input v-if="type === 'checkbox'" type="checkbox" v-model="data[type]">
- *   <input v-else-if="type === 'radio'" type="radio" v-model="data[type]">
- *   <input v-else :type="type" v-model="data[type]">
- */
-
-import {
-  addRawAttr,
-  getBindingAttr,
-  getAndRemoveAttr
-} from 'compiler/helpers'
-
-import {
-  processFor,
-  processElement,
-  addIfCondition,
-  createASTElement
-} from 'compiler/parser/index'
-
-function preTransformNode (el: ASTElement, options: CompilerOptions) {
-  if (el.tag === 'input') {
-    const map = el.attrsMap
-    if (!map['v-model']) {
-      return
-    }
-
-    let typeBinding
-    if (map[':type'] || map['v-bind:type']) {
-      typeBinding = getBindingAttr(el, 'type')
-    }
-    if (!map.type && !typeBinding && map['v-bind']) {
-      typeBinding = `(${map['v-bind']}).type`
-    }
-
-    if (typeBinding) {
-      const ifCondition = getAndRemoveAttr(el, 'v-if', true)
-      const ifConditionExtra = ifCondition ? `&&(${ifCondition})` : ``
-      const hasElse = getAndRemoveAttr(el, 'v-else', true) != null
-      const elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true)
-      // 1. checkbox
-      const branch0 = cloneASTElement(el)
-      // process for on the main node
-      processFor(branch0)
-      addRawAttr(branch0, 'type', 'checkbox')
-      processElement(branch0, options)
-      branch0.processed = true // prevent it from double-processed
-      branch0.if = `(${typeBinding})==='checkbox'` + ifConditionExtra
-      addIfCondition(branch0, {
-        exp: branch0.if,
-        block: branch0
-      })
-      // 2. add radio else-if condition
-      const branch1 = cloneASTElement(el)
-      getAndRemoveAttr(branch1, 'v-for', true)
-      addRawAttr(branch1, 'type', 'radio')
-      processElement(branch1, options)
-      addIfCondition(branch0, {
-        exp: `(${typeBinding})==='radio'` + ifConditionExtra,
-        block: branch1
-      })
-      // 3. other
-      const branch2 = cloneASTElement(el)
-      getAndRemoveAttr(branch2, 'v-for', true)
-      addRawAttr(branch2, ':type', typeBinding)
-      processElement(branch2, options)
-      addIfCondition(branch0, {
-        exp: ifCondition,
-        block: branch2
-      })
-
-      if (hasElse) {
-        branch0.else = true
-      } else if (elseIfCondition) {
-        branch0.elseif = elseIfCondition
-      }
-
-      return branch0
-    }
-  }
-}
-
-function cloneASTElement (el) {
-  return createASTElement(el.tag, el.attrsList.slice(), el.parent)
-}
-
-export default {
-  preTransformNode
-}
diff --git a/1.Vue/src/platforms/web/compiler/modules/style.js b/1.Vue/src/platforms/web/compiler/modules/style.js
deleted file mode 100644
index 8c6bb98..0000000
--- a/1.Vue/src/platforms/web/compiler/modules/style.js
+++ /dev/null
@@ -1,52 +0,0 @@
-/* @flow */
-
-import { parseText } from 'compiler/parser/text-parser'
-import { parseStyleText } from 'web/util/style'
-import {
-  getAndRemoveAttr,
-  getBindingAttr,
-  baseWarn
-} from 'compiler/helpers'
-
-function transformNode (el: ASTElement, options: CompilerOptions) {
-  const warn = options.warn || baseWarn
-  const staticStyle = getAndRemoveAttr(el, 'style')
-  if (staticStyle) {
-    /* istanbul ignore if */
-    if (process.env.NODE_ENV !== 'production') {
-      const res = parseText(staticStyle, options.delimiters)
-      if (res) {
-        warn(
-          `style="${staticStyle}": ` +
-          'Interpolation inside attributes has been removed. ' +
-          'Use v-bind or the colon shorthand instead. For example, ' +
-          'instead of <div style="{{ val }}">, use <div :style="val">.',
-          el.rawAttrsMap['style']
-        )
-      }
-    }
-    el.staticStyle = JSON.stringify(parseStyleText(staticStyle))
-  }
-
-  const styleBinding = getBindingAttr(el, 'style', false /* getStatic */)
-  if (styleBinding) {
-    el.styleBinding = styleBinding
-  }
-}
-
-function genData (el: ASTElement): string {
-  let data = ''
-  if (el.staticStyle) {
-    data += `staticStyle:${el.staticStyle},`
-  }
-  if (el.styleBinding) {
-    data += `style:(${el.styleBinding}),`
-  }
-  return data
-}
-
-export default {
-  staticKeys: ['staticStyle'],
-  transformNode,
-  genData
-}
diff --git a/1.Vue/src/platforms/web/compiler/options.js b/1.Vue/src/platforms/web/compiler/options.js
deleted file mode 100644
index 70c0c48..0000000
--- a/1.Vue/src/platforms/web/compiler/options.js
+++ /dev/null
@@ -1,26 +0,0 @@
-/* @flow */
-
-import {
-  isPreTag,
-  mustUseProp,
-  isReservedTag,
-  getTagNamespace
-} from '../util/index'
-
-import modules from './modules/index'
-import directives from './directives/index'
-import { genStaticKeys } from 'shared/util'
-import { isUnaryTag, canBeLeftOpenTag } from './util'
-
-export const baseOptions: CompilerOptions = {
-  expectHTML: true,
-  modules,
-  directives,
-  isPreTag,
-  isUnaryTag,
-  mustUseProp,
-  canBeLeftOpenTag,
-  isReservedTag,
-  getTagNamespace,
-  staticKeys: genStaticKeys(modules)
-}
diff --git a/1.Vue/src/platforms/web/compiler/util.js b/1.Vue/src/platforms/web/compiler/util.js
deleted file mode 100644
index 7d9394d..0000000
--- a/1.Vue/src/platforms/web/compiler/util.js
+++ /dev/null
@@ -1,24 +0,0 @@
-/* @flow */
-
-import { makeMap } from 'shared/util'
-
-export const isUnaryTag = makeMap(
-  'area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
-  'link,meta,param,source,track,wbr'
-)
-
-// Elements that you can, intentionally, leave open
-// (and which close themselves)
-export const canBeLeftOpenTag = makeMap(
-  'colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source'
-)
-
-// HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
-// Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
-export const isNonPhrasingTag = makeMap(
-  'address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
-  'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
-  'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
-  'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
-  'title,tr,track'
-)
diff --git a/1.Vue/src/platforms/web/entry-compiler.js b/1.Vue/src/platforms/web/entry-compiler.js
deleted file mode 100644
index 15a4f68..0000000
--- a/1.Vue/src/platforms/web/entry-compiler.js
+++ /dev/null
@@ -1,6 +0,0 @@
-/* @flow */
-
-export { parseComponent } from 'sfc/parser'
-export { compile, compileToFunctions } from './compiler/index'
-export { ssrCompile, ssrCompileToFunctions } from './server/compiler'
-export { generateCodeFrame } from 'compiler/codeframe'
diff --git a/1.Vue/src/platforms/web/entry-runtime-with-compiler.js b/1.Vue/src/platforms/web/entry-runtime-with-compiler.js
deleted file mode 100644
index 2bb4636..0000000
--- a/1.Vue/src/platforms/web/entry-runtime-with-compiler.js
+++ /dev/null
@@ -1,101 +0,0 @@
-/* @flow */
-
-import config from 'core/config'
-import { warn, cached } from 'core/util/index'
-import { mark, measure } from 'core/util/perf'
-
-import Vue from './runtime/index'
-import { query } from './util/index'
-import { compileToFunctions } from './compiler/index'
-import { shouldDecodeNewlines, shouldDecodeNewlinesForHref } from './util/compat'
-
-const idToTemplate = cached(id => {
-  const el = query(id)
-  return el && el.innerHTML
-})
-
-const mount = Vue.prototype.$mount
-Vue.prototype.$mount = function (
-  el?: string | Element,
-  hydrating?: boolean
-): Component {
-  el = el && query(el)
-
-  /* istanbul ignore if */
-  if (el === document.body || el === document.documentElement) {
-    process.env.NODE_ENV !== 'production' && warn(
-      `Do not mount Vue to <html> or <body> - mount to normal elements instead.`
-    )
-    return this
-  }
-
-  const options = this.$options
-  // resolve template/el and convert to render function
-  if (!options.render) {
-    let template = options.template
-    if (template) {
-      if (typeof template === 'string') {
-        if (template.charAt(0) === '#') {
-          template = idToTemplate(template)
-          /* istanbul ignore if */
-          if (process.env.NODE_ENV !== 'production' && !template) {
-            warn(
-              `Template element not found or is empty: ${options.template}`,
-              this
-            )
-          }
-        }
-      } else if (template.nodeType) {
-        template = template.innerHTML
-      } else {
-        if (process.env.NODE_ENV !== 'production') {
-          warn('invalid template option:' + template, this)
-        }
-        return this
-      }
-    } else if (el) {
-      template = getOuterHTML(el)
-    }
-    if (template) {
-      /* istanbul ignore if */
-      if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
-        mark('compile')
-      }
-
-      const { render, staticRenderFns } = compileToFunctions(template, {
-        outputSourceRange: process.env.NODE_ENV !== 'production',
-        shouldDecodeNewlines,
-        shouldDecodeNewlinesForHref,
-        delimiters: options.delimiters,
-        comments: options.comments
-      }, this)
-      options.render = render
-      options.staticRenderFns = staticRenderFns
-
-      /* istanbul ignore if */
-      if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
-        mark('compile end')
-        measure(`vue ${this._name} compile`, 'compile', 'compile end')
-      }
-    }
-  }
-  return mount.call(this, el, hydrating)
-}
-
-/**
- * Get outerHTML of elements, taking care
- * of SVG elements in IE as well.
- */
-function getOuterHTML (el: Element): string {
-  if (el.outerHTML) {
-    return el.outerHTML
-  } else {
-    const container = document.createElement('div')
-    container.appendChild(el.cloneNode(true))
-    return container.innerHTML
-  }
-}
-
-Vue.compile = compileToFunctions
-
-export default Vue
diff --git a/1.Vue/src/platforms/web/entry-runtime.js b/1.Vue/src/platforms/web/entry-runtime.js
deleted file mode 100644
index 27c97ff..0000000
--- a/1.Vue/src/platforms/web/entry-runtime.js
+++ /dev/null
@@ -1,5 +0,0 @@
-/* @flow */
-
-import Vue from './runtime/index'
-
-export default Vue
diff --git a/1.Vue/src/platforms/web/entry-server-basic-renderer.js b/1.Vue/src/platforms/web/entry-server-basic-renderer.js
deleted file mode 100644
index c4b973b..0000000
--- a/1.Vue/src/platforms/web/entry-server-basic-renderer.js
+++ /dev/null
@@ -1,13 +0,0 @@
-/* @flow */
-
-import modules from './server/modules/index'
-import directives from './server/directives/index'
-import { isUnaryTag, canBeLeftOpenTag } from './compiler/util'
-import { createBasicRenderer } from 'server/create-basic-renderer'
-
-export default createBasicRenderer({
-  modules,
-  directives,
-  isUnaryTag,
-  canBeLeftOpenTag
-})
diff --git a/1.Vue/src/platforms/web/entry-server-renderer.js b/1.Vue/src/platforms/web/entry-server-renderer.js
deleted file mode 100644
index f61f601..0000000
--- a/1.Vue/src/platforms/web/entry-server-renderer.js
+++ /dev/null
@@ -1,27 +0,0 @@
-/* @flow */
-
-process.env.VUE_ENV = 'server'
-
-import { extend } from 'shared/util'
-import modules from './server/modules/index'
-import baseDirectives from './server/directives/index'
-import { isUnaryTag, canBeLeftOpenTag } from './compiler/util'
-
-import { createRenderer as _createRenderer } from 'server/create-renderer'
-import { createBundleRendererCreator } from 'server/bundle-renderer/create-bundle-renderer'
-
-export function createRenderer (options?: Object = {}): {
-  renderToString: Function,
-  renderToStream: Function
-} {
-  return _createRenderer(extend(extend({}, options), {
-    isUnaryTag,
-    canBeLeftOpenTag,
-    modules,
-    // user can provide server-side implementations for custom directives
-    // when creating the renderer.
-    directives: extend(baseDirectives, options.directives)
-  }))
-}
-
-export const createBundleRenderer = createBundleRendererCreator(createRenderer)
diff --git a/1.Vue/src/platforms/web/runtime/class-util.js b/1.Vue/src/platforms/web/runtime/class-util.js
deleted file mode 100644
index 12f0b5e..0000000
--- a/1.Vue/src/platforms/web/runtime/class-util.js
+++ /dev/null
@@ -1,63 +0,0 @@
-/* @flow */
-
-const whitespaceRE = /\s+/
-
-/**
- * Add class with compatibility for SVG since classList is not supported on
- * SVG elements in IE
- */
-export function addClass (el: HTMLElement, cls: ?string) {
-  /* istanbul ignore if */
-  if (!cls || !(cls = cls.trim())) {
-    return
-  }
-
-  /* istanbul ignore else */
-  if (el.classList) {
-    if (cls.indexOf(' ') > -1) {
-      cls.split(whitespaceRE).forEach(c => el.classList.add(c))
-    } else {
-      el.classList.add(cls)
-    }
-  } else {
-    const 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
- */
-export function removeClass (el: HTMLElement, cls: ?string) {
-  /* istanbul ignore if */
-  if (!cls || !(cls = cls.trim())) {
-    return
-  }
-
-  /* istanbul ignore else */
-  if (el.classList) {
-    if (cls.indexOf(' ') > -1) {
-      cls.split(whitespaceRE).forEach(c => el.classList.remove(c))
-    } else {
-      el.classList.remove(cls)
-    }
-    if (!el.classList.length) {
-      el.removeAttribute('class')
-    }
-  } else {
-    let cur = ` ${el.getAttribute('class') || ''} `
-    const tar = ' ' + cls + ' '
-    while (cur.indexOf(tar) >= 0) {
-      cur = cur.replace(tar, ' ')
-    }
-    cur = cur.trim()
-    if (cur) {
-      el.setAttribute('class', cur)
-    } else {
-      el.removeAttribute('class')
-    }
-  }
-}
diff --git a/1.Vue/src/platforms/web/runtime/components/index.js b/1.Vue/src/platforms/web/runtime/components/index.js
deleted file mode 100644
index 6bfe578..0000000
--- a/1.Vue/src/platforms/web/runtime/components/index.js
+++ /dev/null
@@ -1,7 +0,0 @@
-import Transition from './transition'
-import TransitionGroup from './transition-group'
-
-export default {
-  Transition,
-  TransitionGroup
-}
diff --git a/1.Vue/src/platforms/web/runtime/components/transition-group.js b/1.Vue/src/platforms/web/runtime/components/transition-group.js
deleted file mode 100644
index 084f394..0000000
--- a/1.Vue/src/platforms/web/runtime/components/transition-group.js
+++ /dev/null
@@ -1,190 +0,0 @@
-/* @flow */
-
-// Provides transition support for list items.
-// supports move transitions using the FLIP technique.
-
-// Because the vdom's children update algorithm is "unstable" - i.e.
-// it doesn't guarantee the relative positioning of removed elements,
-// we force transition-group to update its children into two passes:
-// in the first pass, we remove all nodes that need to be removed,
-// triggering their leaving transition; in the second pass, we insert/move
-// into the final desired state. This way in the second pass removed
-// nodes will remain where they should be.
-
-import { warn, extend } from 'core/util/index'
-import { addClass, removeClass } from '../class-util'
-import { transitionProps, extractTransitionData } from './transition'
-import { setActiveInstance } from 'core/instance/lifecycle'
-
-import {
-  hasTransition,
-  getTransitionInfo,
-  transitionEndEvent,
-  addTransitionClass,
-  removeTransitionClass
-} from '../transition-util'
-
-const props = extend({
-  tag: String,
-  moveClass: String
-}, transitionProps)
-
-delete props.mode
-
-export default {
-  props,
-
-  beforeMount () {
-    const update = this._update
-    this._update = (vnode, hydrating) => {
-      const restoreActiveInstance = setActiveInstance(this)
-      // force removing pass
-      this.__patch__(
-        this._vnode,
-        this.kept,
-        false, // hydrating
-        true // removeOnly (!important, avoids unnecessary moves)
-      )
-      this._vnode = this.kept
-      restoreActiveInstance()
-      update.call(this, vnode, hydrating)
-    }
-  },
-
-  render (h: Function) {
-    const tag: string = this.tag || this.$vnode.data.tag || 'span'
-    const map: Object = Object.create(null)
-    const prevChildren: Array<VNode> = this.prevChildren = this.children
-    const rawChildren: Array<VNode> = this.$slots.default || []
-    const children: Array<VNode> = this.children = []
-    const transitionData: Object = extractTransitionData(this)
-
-    for (let i = 0; i < rawChildren.length; i++) {
-      const c: VNode = rawChildren[i]
-      if (c.tag) {
-        if (c.key != null && String(c.key).indexOf('__vlist') !== 0) {
-          children.push(c)
-          map[c.key] = c
-          ;(c.data || (c.data = {})).transition = transitionData
-        } else if (process.env.NODE_ENV !== 'production') {
-          const opts: ?VNodeComponentOptions = c.componentOptions
-          const name: string = opts ? (opts.Ctor.options.name || opts.tag || '') : c.tag
-          warn(`<transition-group> children must be keyed: <${name}>`)
-        }
-      }
-    }
-
-    if (prevChildren) {
-      const kept: Array<VNode> = []
-      const removed: Array<VNode> = []
-      for (let i = 0; i < prevChildren.length; i++) {
-        const c: VNode = prevChildren[i]
-        c.data.transition = transitionData
-        c.data.pos = c.elm.getBoundingClientRect()
-        if (map[c.key]) {
-          kept.push(c)
-        } else {
-          removed.push(c)
-        }
-      }
-      this.kept = h(tag, null, kept)
-      this.removed = removed
-    }
-
-    return h(tag, null, children)
-  },
-
-  updated () {
-    const children: Array<VNode> = this.prevChildren
-    const moveClass: string = this.moveClass || ((this.name || 'v') + '-move')
-    if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
-      return
-    }
-
-    // we divide the work into three loops to avoid mixing DOM reads and writes
-    // in each iteration - which helps prevent layout thrashing.
-    children.forEach(callPendingCbs)
-    children.forEach(recordPosition)
-    children.forEach(applyTranslation)
-
-    // force reflow to put everything in position
-    // assign to this to avoid being removed in tree-shaking
-    // $flow-disable-line
-    this._reflow = document.body.offsetHeight
-
-    children.forEach((c: VNode) => {
-      if (c.data.moved) {
-        const el: any = c.elm
-        const s: any = el.style
-        addTransitionClass(el, moveClass)
-        s.transform = s.WebkitTransform = s.transitionDuration = ''
-        el.addEventListener(transitionEndEvent, el._moveCb = function cb (e) {
-          if (e && e.target !== el) {
-            return
-          }
-          if (!e || /transform$/.test(e.propertyName)) {
-            el.removeEventListener(transitionEndEvent, cb)
-            el._moveCb = null
-            removeTransitionClass(el, moveClass)
-          }
-        })
-      }
-    })
-  },
-
-  methods: {
-    hasMove (el: any, moveClass: string): boolean {
-      /* istanbul ignore if */
-      if (!hasTransition) {
-        return false
-      }
-      /* istanbul ignore if */
-      if (this._hasMove) {
-        return this._hasMove
-      }
-      // Detect whether an element with the move class applied has
-      // CSS transitions. Since the element may be inside an entering
-      // transition at this very moment, we make a clone of it and remove
-      // all other transition classes applied to ensure only the move class
-      // is applied.
-      const clone: HTMLElement = el.cloneNode()
-      if (el._transitionClasses) {
-        el._transitionClasses.forEach((cls: string) => { removeClass(clone, cls) })
-      }
-      addClass(clone, moveClass)
-      clone.style.display = 'none'
-      this.$el.appendChild(clone)
-      const info: Object = getTransitionInfo(clone)
-      this.$el.removeChild(clone)
-      return (this._hasMove = info.hasTransform)
-    }
-  }
-}
-
-function callPendingCbs (c: VNode) {
-  /* istanbul ignore if */
-  if (c.elm._moveCb) {
-    c.elm._moveCb()
-  }
-  /* istanbul ignore if */
-  if (c.elm._enterCb) {
-    c.elm._enterCb()
-  }
-}
-
-function recordPosition (c: VNode) {
-  c.data.newPos = c.elm.getBoundingClientRect()
-}
-
-function applyTranslation (c: VNode) {
-  const oldPos = c.data.pos
-  const newPos = c.data.newPos
-  const dx = oldPos.left - newPos.left
-  const dy = oldPos.top - newPos.top
-  if (dx || dy) {
-    c.data.moved = true
-    const s = c.elm.style
-    s.transform = s.WebkitTransform = `translate(${dx}px,${dy}px)`
-    s.transitionDuration = '0s'
-  }
-}
diff --git a/1.Vue/src/platforms/web/runtime/components/transition.js b/1.Vue/src/platforms/web/runtime/components/transition.js
deleted file mode 100644
index 84fe829..0000000
--- a/1.Vue/src/platforms/web/runtime/components/transition.js
+++ /dev/null
@@ -1,198 +0,0 @@
-/* @flow */
-
-// Provides transition support for a single element/component.
-// supports transition mode (out-in / in-out)
-
-import { warn } from 'core/util/index'
-import { camelize, extend, isPrimitive } from 'shared/util'
-import {
-  mergeVNodeHook,
-  isAsyncPlaceholder,
-  getFirstComponentChild
-} from 'core/vdom/helpers/index'
-
-export const transitionProps = {
-  name: String,
-  appear: Boolean,
-  css: Boolean,
-  mode: String,
-  type: String,
-  enterClass: String,
-  leaveClass: String,
-  enterToClass: String,
-  leaveToClass: String,
-  enterActiveClass: String,
-  leaveActiveClass: String,
-  appearClass: String,
-  appearActiveClass: String,
-  appearToClass: String,
-  duration: [Number, String, Object]
-}
-
-// in case the child is also an abstract component, e.g. <keep-alive>
-// we want to recursively retrieve the real component to be rendered
-function getRealChild (vnode: ?VNode): ?VNode {
-  const compOptions: ?VNodeComponentOptions = vnode && vnode.componentOptions
-  if (compOptions && compOptions.Ctor.options.abstract) {
-    return getRealChild(getFirstComponentChild(compOptions.children))
-  } else {
-    return vnode
-  }
-}
-
-export function extractTransitionData (comp: Component): Object {
-  const data = {}
-  const options: ComponentOptions = comp.$options
-  // props
-  for (const key in options.propsData) {
-    data[key] = comp[key]
-  }
-  // events.
-  // extract listeners and pass them directly to the transition methods
-  const listeners: ?Object = options._parentListeners
-  for (const key in listeners) {
-    data[camelize(key)] = listeners[key]
-  }
-  return data
-}
-
-function placeholder (h: Function, rawChild: VNode): ?VNode {
-  if (/\d-keep-alive$/.test(rawChild.tag)) {
-    return h('keep-alive', {
-      props: rawChild.componentOptions.propsData
-    })
-  }
-}
-
-function hasParentTransition (vnode: VNode): ?boolean {
-  while ((vnode = vnode.parent)) {
-    if (vnode.data.transition) {
-      return true
-    }
-  }
-}
-
-function isSameChild (child: VNode, oldChild: VNode): boolean {
-  return oldChild.key === child.key && oldChild.tag === child.tag
-}
-
-const isNotTextNode = (c: VNode) => c.tag || isAsyncPlaceholder(c)
-
-const isVShowDirective = d => d.name === 'show'
-
-export default {
-  name: 'transition',
-  props: transitionProps,
-  abstract: true,
-
-  render (h: Function) {
-    let children: any = this.$slots.default
-    if (!children) {
-      return
-    }
-
-    // filter out text nodes (possible whitespaces)
-    children = children.filter(isNotTextNode)
-    /* istanbul ignore if */
-    if (!children.length) {
-      return
-    }
-
-    // warn multiple elements
-    if (process.env.NODE_ENV !== 'production' && children.length > 1) {
-      warn(
-        '<transition> can only be used on a single element. Use ' +
-        '<transition-group> for lists.',
-        this.$parent
-      )
-    }
-
-    const mode: string = this.mode
-
-    // warn invalid mode
-    if (process.env.NODE_ENV !== 'production' &&
-      mode && mode !== 'in-out' && mode !== 'out-in'
-    ) {
-      warn(
-        'invalid <transition> mode: ' + mode,
-        this.$parent
-      )
-    }
-
-    const rawChild: VNode = children[0]
-
-    // if this is a component root node and the component's
-    // parent container node also has transition, skip.
-    if (hasParentTransition(this.$vnode)) {
-      return rawChild
-    }
-
-    // apply transition data to child
-    // use getRealChild() to ignore abstract components e.g. keep-alive
-    const child: ?VNode = getRealChild(rawChild)
-    /* istanbul ignore if */
-    if (!child) {
-      return rawChild
-    }
-
-    if (this._leaving) {
-      return placeholder(h, rawChild)
-    }
-
-    // ensure a key that is unique to the vnode type and to this transition
-    // component instance. This key will be used to remove pending leaving nodes
-    // during entering.
-    const id: string = `__transition-${this._uid}-`
-    child.key = child.key == null
-      ? child.isComment
-        ? id + 'comment'
-        : id + child.tag
-      : isPrimitive(child.key)
-        ? (String(child.key).indexOf(id) === 0 ? child.key : id + child.key)
-        : child.key
-
-    const data: Object = (child.data || (child.data = {})).transition = extractTransitionData(this)
-    const oldRawChild: VNode = this._vnode
-    const oldChild: VNode = getRealChild(oldRawChild)
-
-    // mark v-show
-    // so that the transition module can hand over the control to the directive
-    if (child.data.directives && child.data.directives.some(isVShowDirective)) {
-      child.data.show = true
-    }
-
-    if (
-      oldChild &&
-      oldChild.data &&
-      !isSameChild(child, oldChild) &&
-      !isAsyncPlaceholder(oldChild) &&
-      // #6687 component root is a comment node
-      !(oldChild.componentInstance && oldChild.componentInstance._vnode.isComment)
-    ) {
-      // replace old child transition data with fresh one
-      // important for dynamic transitions!
-      const oldData: Object = oldChild.data.transition = extend({}, data)
-      // handle transition mode
-      if (mode === 'out-in') {
-        // return placeholder node and queue update when leave finishes
-        this._leaving = true
-        mergeVNodeHook(oldData, 'afterLeave', () => {
-          this._leaving = false
-          this.$forceUpdate()
-        })
-        return placeholder(h, rawChild)
-      } else if (mode === 'in-out') {
-        if (isAsyncPlaceholder(child)) {
-          return oldRawChild
-        }
-        let delayedLeave
-        const performLeave = () => { delayedLeave() }
-        mergeVNodeHook(data, 'afterEnter', performLeave)
-        mergeVNodeHook(data, 'enterCancelled', performLeave)
-        mergeVNodeHook(oldData, 'delayLeave', leave => { delayedLeave = leave })
-      }
-    }
-
-    return rawChild
-  }
-}
diff --git a/1.Vue/src/platforms/web/runtime/directives/index.js b/1.Vue/src/platforms/web/runtime/directives/index.js
deleted file mode 100644
index b673f11..0000000
--- a/1.Vue/src/platforms/web/runtime/directives/index.js
+++ /dev/null
@@ -1,7 +0,0 @@
-import model from './model'
-import show from './show'
-
-export default {
-  model,
-  show
-}
diff --git a/1.Vue/src/platforms/web/runtime/directives/model.js b/1.Vue/src/platforms/web/runtime/directives/model.js
deleted file mode 100644
index cba8ded..0000000
--- a/1.Vue/src/platforms/web/runtime/directives/model.js
+++ /dev/null
@@ -1,147 +0,0 @@
-/**
- * Not type checking this file because flow doesn't like attaching
- * properties to Elements.
- */
-
-import { isTextInputType } from 'web/util/element'
-import { looseEqual, looseIndexOf } from 'shared/util'
-import { mergeVNodeHook } from 'core/vdom/helpers/index'
-import { warn, isIE9, isIE, isEdge } from 'core/util/index'
-
-/* istanbul ignore if */
-if (isIE9) {
-  // http://www.matts411.com/post/internet-explorer-9-oninput/
-  document.addEventListener('selectionchange', () => {
-    const el = document.activeElement
-    if (el && el.vmodel) {
-      trigger(el, 'input')
-    }
-  })
-}
-
-const directive = {
-  inserted (el, binding, vnode, oldVnode) {
-    if (vnode.tag === 'select') {
-      // #6903
-      if (oldVnode.elm && !oldVnode.elm._vOptions) {
-        mergeVNodeHook(vnode, 'postpatch', () => {
-          directive.componentUpdated(el, binding, vnode)
-        })
-      } else {
-        setSelected(el, binding, vnode.context)
-      }
-      el._vOptions = [].map.call(el.options, getValue)
-    } else if (vnode.tag === 'textarea' || isTextInputType(el.type)) {
-      el._vModifiers = binding.modifiers
-      if (!binding.modifiers.lazy) {
-        el.addEventListener('compositionstart', onCompositionStart)
-        el.addEventListener('compositionend', onCompositionEnd)
-        // Safari < 10.2 & UIWebView doesn't fire compositionend when
-        // switching focus before confirming composition choice
-        // this also fixes the issue where some browsers e.g. iOS Chrome
-        // fires "change" instead of "input" on autocomplete.
-        el.addEventListener('change', onCompositionEnd)
-        /* istanbul ignore if */
-        if (isIE9) {
-          el.vmodel = true
-        }
-      }
-    }
-  },
-
-  componentUpdated (el, binding, vnode) {
-    if (vnode.tag === 'select') {
-      setSelected(el, binding, vnode.context)
-      // in case the options rendered by v-for have changed,
-      // it's possible that the value is out-of-sync with the rendered options.
-      // detect such cases and filter out values that no longer has a matching
-      // option in the DOM.
-      const prevOptions = el._vOptions
-      const curOptions = el._vOptions = [].map.call(el.options, getValue)
-      if (curOptions.some((o, i) => !looseEqual(o, prevOptions[i]))) {
-        // trigger change event if
-        // no matching option found for at least one value
-        const needReset = el.multiple
-          ? binding.value.some(v => hasNoMatchingOption(v, curOptions))
-          : binding.value !== binding.oldValue && hasNoMatchingOption(binding.value, curOptions)
-        if (needReset) {
-          trigger(el, 'change')
-        }
-      }
-    }
-  }
-}
-
-function setSelected (el, binding, vm) {
-  actuallySetSelected(el, binding, vm)
-  /* istanbul ignore if */
-  if (isIE || isEdge) {
-    setTimeout(() => {
-      actuallySetSelected(el, binding, vm)
-    }, 0)
-  }
-}
-
-function actuallySetSelected (el, binding, vm) {
-  const value = binding.value
-  const isMultiple = el.multiple
-  if (isMultiple && !Array.isArray(value)) {
-    process.env.NODE_ENV !== 'production' && warn(
-      `<select multiple v-model="${binding.expression}"> ` +
-      `expects an Array value for its binding, but got ${
-        Object.prototype.toString.call(value).slice(8, -1)
-      }`,
-      vm
-    )
-    return
-  }
-  let selected, option
-  for (let i = 0, l = el.options.length; i < l; i++) {
-    option = el.options[i]
-    if (isMultiple) {
-      selected = looseIndexOf(value, getValue(option)) > -1
-      if (option.selected !== selected) {
-        option.selected = selected
-      }
-    } else {
-      if (looseEqual(getValue(option), value)) {
-        if (el.selectedIndex !== i) {
-          el.selectedIndex = i
-        }
-        return
-      }
-    }
-  }
-  if (!isMultiple) {
-    el.selectedIndex = -1
-  }
-}
-
-function hasNoMatchingOption (value, options) {
-  return options.every(o => !looseEqual(o, value))
-}
-
-function getValue (option) {
-  return '_value' in option
-    ? option._value
-    : option.value
-}
-
-function onCompositionStart (e) {
-  e.target.composing = true
-}
-
-function onCompositionEnd (e) {
-  // prevent triggering an input event for no reason
-  if (!e.target.composing) return
-  e.target.composing = false
-  trigger(e.target, 'input')
-}
-
-function trigger (el, type) {
-  const e = document.createEvent('HTMLEvents')
-  e.initEvent(type, true, true)
-  el.dispatchEvent(e)
-}
-
-export default directive
diff --git a/1.Vue/src/platforms/web/runtime/directives/show.js b/1.Vue/src/platforms/web/runtime/directives/show.js
deleted file mode 100644
index 17fb5de..0000000
--- a/1.Vue/src/platforms/web/runtime/directives/show.js
+++ /dev/null
@@ -1,60 +0,0 @@
-/* @flow */
-
-import { enter, leave } from '../modules/transition'
-
-// recursively search for possible transition defined inside the component root
-function locateNode (vnode: VNode): VNodeWithData {
-  return vnode.componentInstance && (!vnode.data || !vnode.data.transition)
-    ? locateNode(vnode.componentInstance._vnode)
-    : vnode
-}
-
-export default {
-  bind (el: any, { value }: VNodeDirective, vnode: VNodeWithData) {
-    vnode = locateNode(vnode)
-    const transition = vnode.data && vnode.data.transition
-    const originalDisplay = el.__vOriginalDisplay =
-      el.style.display === 'none' ? '' : el.style.display
-    if (value && transition) {
-      vnode.data.show = true
-      enter(vnode, () => {
-        el.style.display = originalDisplay
-      })
-    } else {
-      el.style.display = value ? originalDisplay : 'none'
-    }
-  },
-
-  update (el: any, { value, oldValue }: VNodeDirective, vnode: VNodeWithData) {
-    /* istanbul ignore if */
-    if (!value === !oldValue) return
-    vnode = locateNode(vnode)
-    const transition = vnode.data && vnode.data.transition
-    if (transition) {
-      vnode.data.show = true
-      if (value) {
-        enter(vnode, () => {
-          el.style.display = el.__vOriginalDisplay
-        })
-      } else {
-        leave(vnode, () => {
-          el.style.display = 'none'
-        })
-      }
-    } else {
-      el.style.display = value ? el.__vOriginalDisplay : 'none'
-    }
-  },
-
-  unbind (
-    el: any,
-    binding: VNodeDirective,
-    vnode: VNodeWithData,
-    oldVnode: VNodeWithData,
-    isDestroy: boolean
-  ) {
-    if (!isDestroy) {
-      el.style.display = el.__vOriginalDisplay
-    }
-  }
-}
diff --git a/1.Vue/src/platforms/web/runtime/index.js b/1.Vue/src/platforms/web/runtime/index.js
deleted file mode 100644
index fe29b22..0000000
--- a/1.Vue/src/platforms/web/runtime/index.js
+++ /dev/null
@@ -1,76 +0,0 @@
-/* @flow */
-
-import Vue from 'core/index'
-import config from 'core/config'
-import { extend, noop } from 'shared/util'
-import { mountComponent } from 'core/instance/lifecycle'
-import { devtools, inBrowser } from 'core/util/index'
-
-import {
-  query,
-  mustUseProp,
-  isReservedTag,
-  isReservedAttr,
-  getTagNamespace,
-  isUnknownElement
-} from 'web/util/index'
-
-import { patch } from './patch'
-import platformDirectives from './directives/index'
-import platformComponents from './components/index'
-
-// install platform specific utils
-Vue.config.mustUseProp = mustUseProp
-Vue.config.isReservedTag = isReservedTag
-Vue.config.isReservedAttr = isReservedAttr
-Vue.config.getTagNamespace = getTagNamespace
-Vue.config.isUnknownElement = isUnknownElement
-
-// install platform runtime directives & components
-extend(Vue.options.directives, platformDirectives)
-extend(Vue.options.components, platformComponents)
-
-// install platform patch function
-Vue.prototype.__patch__ = inBrowser ? patch : noop
-
-// public mount method
-Vue.prototype.$mount = function (
-  el?: string | Element,
-  hydrating?: boolean
-): Component {
-  el = el && inBrowser ? query(el) : undefined
-  return mountComponent(this, el, hydrating)
-}
-
-// devtools global hook
-/* istanbul ignore next */
-if (inBrowser) {
-  setTimeout(() => {
-    if (config.devtools) {
-      if (devtools) {
-        devtools.emit('init', Vue)
-      } else if (
-        process.env.NODE_ENV !== 'production' &&
-        process.env.NODE_ENV !== 'test'
-      ) {
-        console[console.info ? 'info' : 'log'](
-          'Download the Vue Devtools extension for a better development experience:\n' +
-          'https://github.com/vuejs/vue-devtools'
-        )
-      }
-    }
-    if (process.env.NODE_ENV !== 'production' &&
-      process.env.NODE_ENV !== 'test' &&
-      config.productionTip !== false &&
-      typeof console !== 'undefined'
-    ) {
-      console[console.info ? 'info' : 'log'](
-        `You are running Vue in development mode.\n` +
-        `Make sure to turn on production mode when deploying for production.\n` +
-        `See more tips at https://vuejs.org/guide/deployment.html`
-      )
-    }
-  }, 0)
-}
-
-export default Vue
diff --git a/1.Vue/src/platforms/web/runtime/modules/attrs.js b/1.Vue/src/platforms/web/runtime/modules/attrs.js
deleted file mode 100644
index b5e0640..0000000
--- a/1.Vue/src/platforms/web/runtime/modules/attrs.js
+++ /dev/null
@@ -1,119 +0,0 @@
-/* @flow */
-
-import { isIE, isIE9, isEdge } from 'core/util/env'
-
-import {
-  extend,
-  isDef,
-  isUndef
-} from 'shared/util'
-
-import {
-  isXlink,
-  xlinkNS,
-  getXlinkProp,
-  isBooleanAttr,
-  isEnumeratedAttr,
-  isFalsyAttrValue,
-  convertEnumeratedValue
-} from 'web/util/index'
-
-function updateAttrs (oldVnode: VNodeWithData, vnode: VNodeWithData) {
-  const opts = vnode.componentOptions
-  if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {
-    return
-  }
-  if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) {
-    return
-  }
-  let key, cur, old
-  const elm = vnode.elm
-  const oldAttrs = oldVnode.data.attrs || {}
-  let attrs: any = vnode.data.attrs || {}
-  // clone observed objects, as the user probably wants to mutate it
-  if (isDef(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]
-  // #6666: IE/Edge forces progress value down to 1 before setting a max
-  /* istanbul ignore if */
-  if ((isIE || isEdge) && attrs.value !== oldAttrs.value) {
-    setAttr(elm, 'value', attrs.value)
-  }
-  for (key in oldAttrs) {
-    if (isUndef(attrs[key])) {
-      if (isXlink(key)) {
-        elm.removeAttributeNS(xlinkNS, getXlinkProp(key))
-      } else if (!isEnumeratedAttr(key)) {
-        elm.removeAttribute(key)
-      }
-    }
-  }
-}
-
-function setAttr (el: Element, key: string, value: any) {
-  if (el.tagName.indexOf('-') > -1) {
-    baseSetAttr(el, key, value)
-  } else if (isBooleanAttr(key)) {
-    // set attribute for blank value
-    // e.g. <option disabled>Select one</option>
-    if (isFalsyAttrValue(value)) {
-      el.removeAttribute(key)
-    } else {
-      // technically allowfullscreen is a boolean attribute for <iframe>,
-      // but Flash expects a value of "true" when used on <embed> tag
-      value = key === 'allowfullscreen' && el.tagName === 'EMBED'
-        ? 'true'
-        : key
-      el.setAttribute(key, value)
-    }
-  } else if (isEnumeratedAttr(key)) {
-    el.setAttribute(key, convertEnumeratedValue(key, value))
-  } else if (isXlink(key)) {
-    if (isFalsyAttrValue(value)) {
-      el.removeAttributeNS(xlinkNS, getXlinkProp(key))
-    } else {
-      el.setAttributeNS(xlinkNS, key, value)
-    }
-  } else {
-    baseSetAttr(el, key, value)
-  }
-}
-
-function baseSetAttr (el, key, value) {
-  if (isFalsyAttrValue(value)) {
-    el.removeAttribute(key)
-  } else {
-    // #7138: IE10 & 11 fires input event when setting placeholder on
-    // <textarea>... block the first input event and remove the blocker
-    // immediately.
-    /* istanbul ignore if */
-    if (
-      isIE && !isIE9 &&
-      el.tagName === 'TEXTAREA' &&
-      key === 'placeholder' && value !== '' && !el.__ieph
-    ) {
-      const blocker = e => {
-        e.stopImmediatePropagation()
-        el.removeEventListener('input', blocker)
-      }
-      el.addEventListener('input', blocker)
-      // $flow-disable-line
-      el.__ieph = true /* IE placeholder patched */
-    }
-    el.setAttribute(key, value)
-  }
-}
-
-export default {
-  create: updateAttrs,
-  update: updateAttrs
-}
diff --git a/1.Vue/src/platforms/web/runtime/modules/class.js b/1.Vue/src/platforms/web/runtime/modules/class.js
deleted file mode 100644
index 29fd2c1..0000000
--- a/1.Vue/src/platforms/web/runtime/modules/class.js
+++ /dev/null
@@ -1,48 +0,0 @@
-/* @flow */
-
-import {
-  isDef,
-  isUndef
-} from 'shared/util'
-
-import {
-  concat,
-  stringifyClass,
-  genClassForVnode
-} from 'web/util/index'
-
-function updateClass (oldVnode: any, vnode: any) {
-  const el = vnode.elm
-  const data: VNodeData = vnode.data
-  const oldData: VNodeData = oldVnode.data
-  if (
-    isUndef(data.staticClass) &&
-    isUndef(data.class) && (
-      isUndef(oldData) || (
-        isUndef(oldData.staticClass) &&
-        isUndef(oldData.class)
-      )
-    )
-  ) {
-    return
-  }
-
-  let cls = genClassForVnode(vnode)
-
-  // handle transition classes
-  const transitionClass = el._transitionClasses
-  if (isDef(transitionClass)) {
-    cls = concat(cls, stringifyClass(transitionClass))
-  }
-
-  // set the class
-  if (cls !== el._prevClass) {
-    el.setAttribute('class', cls)
-    el._prevClass = cls
-  }
-}
-
-export default {
-  create: updateClass,
-  update: updateClass
-}
diff --git a/1.Vue/src/platforms/web/runtime/modules/dom-props.js b/1.Vue/src/platforms/web/runtime/modules/dom-props.js
deleted file mode 100644
index a5c3dc7..0000000
--- a/1.Vue/src/platforms/web/runtime/modules/dom-props.js
+++ /dev/null
@@ -1,116 +0,0 @@
-/* @flow */
-
-import { isDef, isUndef, extend, toNumber } from 'shared/util'
-import { isSVG } from 'web/util/index'
-
-let svgContainer
-
-function updateDOMProps (oldVnode: VNodeWithData, vnode: VNodeWithData) {
-  if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {
-    return
-  }
-  let key, cur
-  const elm: any = vnode.elm
-  const oldProps = oldVnode.data.domProps || {}
-  let props = vnode.data.domProps || {}
-  // clone observed objects, as the user probably wants to mutate it
-  if (isDef(props.__ob__)) {
-    props = vnode.data.domProps = extend({}, props)
-  }
-
-  for (key in oldProps) {
-    if (!(key in props)) {
-      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
-      // #6601 work around Chrome version <= 55 bug where single textNode
-      // replaced by innerHTML/textContent retains its parentNode property
-      if (elm.childNodes.length === 1) {
-        elm.removeChild(elm.childNodes[0])
-      }
-    }
-
-    if (key === 'value' && elm.tagName !== 'PROGRESS') {
-      // 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
-      const strCur = isUndef(cur) ? '' : String(cur)
-      if (shouldUpdateValue(elm, strCur)) {
-        elm.value = strCur
-      }
-    } else if (key === 'innerHTML' && isSVG(elm.tagName) && isUndef(elm.innerHTML)) {
-      // IE doesn't support innerHTML for SVG elements
-      svgContainer = svgContainer || document.createElement('div')
-      svgContainer.innerHTML = `<svg>${cur}</svg>`
-      const svg = svgContainer.firstChild
-      while (elm.firstChild) {
-        elm.removeChild(elm.firstChild)
-      }
-      while (svg.firstChild) {
-        elm.appendChild(svg.firstChild)
-      }
-    } else if (
-      // skip the update if old and new VDOM state is the same.
-      // `value` is handled separately because the DOM value may be temporarily
-      // out of sync with VDOM state due to focus, composition and modifiers.
-      // This  #4521 by skipping the unnecesarry `checked` update.
-      cur !== oldProps[key]
-    ) {
-      // some property updates can throw
-      // e.g. `value` on <progress> w/ non-finite value
-      try {
-        elm[key] = cur
-      } catch (e) {}
-    }
-  }
-}
-
-// check platforms/web/util/attrs.js acceptValue
-type acceptValueElm = HTMLInputElement | HTMLSelectElement | HTMLOptionElement;
-
-function shouldUpdateValue (elm: acceptValueElm, checkVal: string): boolean {
-  return (!elm.composing && (
-    elm.tagName === 'OPTION' ||
-    isNotInFocusAndDirty(elm, checkVal) ||
-    isDirtyWithModifiers(elm, checkVal)
-  ))
-}
-
-function isNotInFocusAndDirty (elm: acceptValueElm, checkVal: string): boolean {
-  // return true when textbox (.number and .trim) loses focus and its value is
-  // not equal to the updated value
-  let notInFocus = true
-  // #6157
-  // work around IE bug when accessing document.activeElement in an iframe
-  try { notInFocus = document.activeElement !== elm } catch (e) {}
-  return notInFocus && elm.value !== checkVal
-}
-
-function isDirtyWithModifiers (elm: any, newVal: string): boolean {
-  const value = elm.value
-  const modifiers = elm._vModifiers // injected by v-model runtime
-  if (isDef(modifiers)) {
-    if (modifiers.number) {
-      return toNumber(value) !== toNumber(newVal)
-    }
-    if (modifiers.trim) {
-      return value.trim() !== newVal.trim()
-    }
-  }
-  return value !== newVal
-}
-
-export default {
-  create: updateDOMProps,
-  update: updateDOMProps
-}
diff --git a/1.Vue/src/platforms/web/runtime/modules/events.js b/1.Vue/src/platforms/web/runtime/modules/events.js
deleted file mode 100644
index ecb08af..0000000
--- a/1.Vue/src/platforms/web/runtime/modules/events.js
+++ /dev/null
@@ -1,120 +0,0 @@
-/* @flow */
-
-import { isDef, isUndef } from 'shared/util'
-import { updateListeners } from 'core/vdom/helpers/index'
-import { isIE, isFF, supportsPassive, isUsingMicroTask } from 'core/util/index'
-import { RANGE_TOKEN, CHECKBOX_RADIO_TOKEN } from 'web/compiler/directives/model'
-import { currentFlushTimestamp } from 'core/observer/scheduler'
-
-// 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) {
-  /* istanbul ignore if */
-  if (isDef(on[RANGE_TOKEN])) {
-    // IE input[type=range] only supports `change` event
-    const event = isIE ? 'change' : 'input'
-    on[event] = [].concat(on[RANGE_TOKEN], on[event] || [])
-    delete on[RANGE_TOKEN]
-  }
-  // This was originally intended to fix #4521 but no longer necessary
-  // after 2.5. Keeping it for backwards compat with generated code from < 2.4
-  /* istanbul ignore if */
-  if (isDef(on[CHECKBOX_RADIO_TOKEN])) {
-    on.change = [].concat(on[CHECKBOX_RADIO_TOKEN], on.change || [])
-    delete on[CHECKBOX_RADIO_TOKEN]
-  }
-}
-
-let target: any
-
-function createOnceHandler (event, handler, capture) {
-  const _target = target // save current target element in closure
-  return function onceHandler () {
-    const res = handler.apply(null, arguments)
-    if (res !== null) {
-      remove(event, onceHandler, capture, _target)
-    }
-  }
-}
-
-// #9446: Firefox <= 53 (in particular, ESR 52) has incorrect Event.timeStamp
-// implementation and does not fire microtasks in between event propagation, so
-// safe to exclude.
-const useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53)
-
-function add (
-  name: string,
-  handler: Function,
-  capture: boolean,
-  passive: boolean
-) {
-  // async edge case #6566: inner click event triggers patch, event handler
-  // attached to outer element during patch, and triggered again. This
-  // happens because browsers fire microtask ticks between event propagation.
-  // the solution is simple: we save the timestamp when a handler is attached,
-  // and the handler would only fire if the event passed to it was fired
-  // AFTER it was attached.
-  if (useMicrotaskFix) {
-    const attachedTimestamp = currentFlushTimestamp
-    const original = handler
-    handler = original._wrapper = function (e) {
-      if (
-        // no bubbling, should always fire.
-        // this is just a safety net in case event.timeStamp is unreliable in
-        // certain weird environments...
-        e.target === e.currentTarget ||
-        // event is fired after handler attachment
-        e.timeStamp >= attachedTimestamp ||
-        // bail for environments that have buggy event.timeStamp implementations
-        // #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState
-        // #9681 QtWebEngine event.timeStamp is negative value
-        e.timeStamp <= 0 ||
-        // #9448 bail if event is fired in another document in a multi-page
-        // electron/nw.js app, since event.timeStamp will be using a different
-        // starting reference
-        e.target.ownerDocument !== document
-      ) {
-        return original.apply(this, arguments)
-      }
-    }
-  }
-  target.addEventListener(
-    name,
-    handler,
-    supportsPassive
-      ? { capture, passive }
-      : capture
-  )
-}
-
-function remove (
-  name: string,
-  handler: Function,
-  capture: boolean,
-  _target?: HTMLElement
-) {
-  (_target || target).removeEventListener(
-    name,
-    handler._wrapper || handler,
-    capture
-  )
-}
-
-function updateDOMListeners (oldVnode: VNodeWithData, vnode: VNodeWithData) {
-  if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) {
-    return
-  }
-  const on = vnode.data.on || {}
-  const oldOn = oldVnode.data.on || {}
-  target = vnode.elm
-  normalizeEvents(on)
-  updateListeners(on, oldOn, add, remove, createOnceHandler, vnode.context)
-  target = undefined
-}
-
-export default {
-  create: updateDOMListeners,
-  update: updateDOMListeners
-}
diff --git a/1.Vue/src/platforms/web/runtime/modules/index.js b/1.Vue/src/platforms/web/runtime/modules/index.js
deleted file mode 100644
index 9f6ad8f..0000000
--- a/1.Vue/src/platforms/web/runtime/modules/index.js
+++ /dev/null
@@ -1,15 +0,0 @@
-import attrs from './attrs'
-import klass from './class'
-import events from './events'
-import domProps from './dom-props'
-import style from './style'
-import transition from './transition'
-
-export default [
-  attrs,
-  klass,
-  events,
-  domProps,
-  style,
-  transition
-]
diff --git a/1.Vue/src/platforms/web/runtime/modules/style.js b/1.Vue/src/platforms/web/runtime/modules/style.js
deleted file mode 100644
index 4d2d39d..0000000
--- a/1.Vue/src/platforms/web/runtime/modules/style.js
+++ /dev/null
@@ -1,93 +0,0 @@
-/* @flow */
-
-import { getStyle, normalizeStyleBinding } from 'web/util/style'
-import { cached, camelize, extend, isDef, isUndef, hyphenate } from 'shared/util'
-
-const cssVarRE = /^--/
-const importantRE = /\s*!important$/
-const setProp = (el, name, val) => {
-  /* istanbul ignore if */
-  if (cssVarRE.test(name)) {
-    el.style.setProperty(name, val)
-  } else if (importantRE.test(val)) {
-    el.style.setProperty(hyphenate(name), val.replace(importantRE, ''), 'important')
-  } else {
-    const normalizedName = normalize(name)
-    if (Array.isArray(val)) {
-      // Support values array created by autoprefixer, e.g.
-      // {display: ["-webkit-box", "-ms-flexbox", "flex"]}
-      // Set them one by one, and the browser will only set those it can recognize
-      for (let i = 0, len = val.length; i < len; i++) {
-        el.style[normalizedName] = val[i]
-      }
-    } else {
-      el.style[normalizedName] = val
-    }
-  }
-}
-
-const vendorNames = ['Webkit', 'Moz', 'ms']
-
-let emptyStyle
-const normalize = cached(function (prop) {
-  emptyStyle = emptyStyle || document.createElement('div').style
-  prop = camelize(prop)
-  if (prop !== 'filter' && (prop in emptyStyle)) {
-    return prop
-  }
-  const capName = prop.charAt(0).toUpperCase() + prop.slice(1)
-  for (let i = 0; i < vendorNames.length; i++) {
-    const name = vendorNames[i] + capName
-    if (name in emptyStyle) {
-      return name
-    }
-  }
-})
-
-function updateStyle (oldVnode: VNodeWithData, vnode: VNodeWithData) {
-  const data = vnode.data
-  const oldData = oldVnode.data
-
-  if (isUndef(data.staticStyle) && isUndef(data.style) &&
-    isUndef(oldData.staticStyle) && isUndef(oldData.style)
-  ) {
-    return
-  }
-
-  let cur, name
-  const el: any = vnode.elm
-  const oldStaticStyle: any = oldData.staticStyle
-  const oldStyleBinding: any = oldData.normalizedStyle || oldData.style || {}
-
-  // if static style exists, stylebinding already merged into it when doing normalizeStyleData
-  const oldStyle = oldStaticStyle || oldStyleBinding
-
-  const style = normalizeStyleBinding(vnode.data.style) || {}
-
-  // store normalized style under a different key for next diff
-  // make sure to clone it if it's reactive, since the user likely wants
-  // to mutate it.
-  vnode.data.normalizedStyle = isDef(style.__ob__)
-    ? extend({}, style)
-    : style
-
-  const newStyle = getStyle(vnode, true)
-
-  for (name in oldStyle) {
-    if (isUndef(newStyle[name])) {
-      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)
-    }
-  }
-}
-
-export default {
-  create: updateStyle,
-  update: updateStyle
-}
diff --git a/1.Vue/src/platforms/web/runtime/modules/transition.js b/1.Vue/src/platforms/web/runtime/modules/transition.js
deleted file mode 100644
index 6117097..0000000
--- a/1.Vue/src/platforms/web/runtime/modules/transition.js
+++ /dev/null
@@ -1,343 +0,0 @@
-/* @flow */
-
-import { inBrowser, isIE9, warn } from 'core/util/index'
-import { mergeVNodeHook } from 'core/vdom/helpers/index'
-import { activeInstance } from 'core/instance/lifecycle'
-
-import {
-  once,
-  isDef,
-  isUndef,
-  isObject,
-  toNumber
-} from 'shared/util'
-
-import {
-  nextFrame,
-  resolveTransition,
-  whenTransitionEnds,
-  addTransitionClass,
-  removeTransitionClass
-} from '../transition-util'
-
-export function enter (vnode: VNodeWithData, toggleDisplay: ?() => void) {
-  const el: any = vnode.elm
-
-  // call leave callback now
-  if (isDef(el._leaveCb)) {
-    el._leaveCb.cancelled = true
-    el._leaveCb()
-  }
-
-  const data = resolveTransition(vnode.data.transition)
-  if (isUndef(data)) {
-    return
-  }
-
-  /* istanbul ignore if */
-  if (isDef(el._enterCb) || el.nodeType !== 1) {
-    return
-  }
-
-  const {
-    css,
-    type,
-    enterClass,
-    enterToClass,
-    enterActiveClass,
-    appearClass,
-    appearToClass,
-    appearActiveClass,
-    beforeEnter,
-    enter,
-    afterEnter,
-    enterCancelled,
-    beforeAppear,
-    appear,
-    afterAppear,
-    appearCancelled,
-    duration
-  } = data
-
-  // 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.
-  let context = activeInstance
-  let transitionNode = activeInstance.$vnode
-  while (transitionNode && transitionNode.parent) {
-    context = transitionNode.context
-    transitionNode = transitionNode.parent
-  }
-
-  const isAppear = !context._isMounted || !vnode.isRootInsert
-
-  if (isAppear && !appear && appear !== '') {
-    return
-  }
-
-  const startClass = isAppear && appearClass
-    ? appearClass
-    : enterClass
-  const activeClass = isAppear && appearActiveClass
-    ? appearActiveClass
-    : enterActiveClass
-  const toClass = isAppear && appearToClass
-    ? appearToClass
-    : enterToClass
-
-  const beforeEnterHook = isAppear
-    ? (beforeAppear || beforeEnter)
-    : beforeEnter
-  const enterHook = isAppear
-    ? (typeof appear === 'function' ? appear : enter)
-    : enter
-  const afterEnterHook = isAppear
-    ? (afterAppear || afterEnter)
-    : afterEnter
-  const enterCancelledHook = isAppear
-    ? (appearCancelled || enterCancelled)
-    : enterCancelled
-
-  const explicitEnterDuration: any = toNumber(
-    isObject(duration)
-      ? duration.enter
-      : duration
-  )
-
-  if (process.env.NODE_ENV !== 'production' && explicitEnterDuration != null) {
-    checkDuration(explicitEnterDuration, 'enter', vnode)
-  }
-
-  const expectsCSS = css !== false && !isIE9
-  const userWantsControl = getHookArgumentsLength(enterHook)
-
-  const cb = el._enterCb = once(() => {
-    if (expectsCSS) {
-      removeTransitionClass(el, toClass)
-      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, 'insert', () => {
-      const parent = el.parentNode
-      const pendingNode = parent && parent._pending && parent._pending[vnode.key]
-      if (pendingNode &&
-        pendingNode.tag === vnode.tag &&
-        pendingNode.elm._leaveCb
-      ) {
-        pendingNode.elm._leaveCb()
-      }
-      enterHook && enterHook(el, cb)
-    })
-  }
-
-  // start enter transition
-  beforeEnterHook && beforeEnterHook(el)
-  if (expectsCSS) {
-    addTransitionClass(el, startClass)
-    addTransitionClass(el, activeClass)
-    nextFrame(() => {
-      removeTransitionClass(el, startClass)
-      if (!cb.cancelled) {
-        addTransitionClass(el, toClass)
-        if (!userWantsControl) {
-          if (isValidDuration(explicitEnterDuration)) {
-            setTimeout(cb, explicitEnterDuration)
-          } else {
-            whenTransitionEnds(el, type, cb)
-          }
-        }
-      }
-    })
-  }
-
-  if (vnode.data.show) {
-    toggleDisplay && toggleDisplay()
-    enterHook && enterHook(el, cb)
-  }
-
-  if (!expectsCSS && !userWantsControl) {
-    cb()
-  }
-}
-
-export function leave (vnode: VNodeWithData, rm: Function) {
-  const el: any = vnode.elm
-
-  // call enter callback now
-  if (isDef(el._enterCb)) {
-    el._enterCb.cancelled = true
-    el._enterCb()
-  }
-
-  const data = resolveTransition(vnode.data.transition)
-  if (isUndef(data) || el.nodeType !== 1) {
-    return rm()
-  }
-
-  /* istanbul ignore if */
-  if (isDef(el._leaveCb)) {
-    return
-  }
-
-  const {
-    css,
-    type,
-    leaveClass,
-    leaveToClass,
-    leaveActiveClass,
-    beforeLeave,
-    leave,
-    afterLeave,
-    leaveCancelled,
-    delayLeave,
-    duration
-  } = data
-
-  const expectsCSS = css !== false && !isIE9
-  const userWantsControl = getHookArgumentsLength(leave)
-
-  const explicitLeaveDuration: any = toNumber(
-    isObject(duration)
-      ? duration.leave
-      : duration
-  )
-
-  if (process.env.NODE_ENV !== 'production' && isDef(explicitLeaveDuration)) {
-    checkDuration(explicitLeaveDuration, 'leave', vnode)
-  }
-
-  const cb = el._leaveCb = once(() => {
-    if (el.parentNode && el.parentNode._pending) {
-      el.parentNode._pending[vnode.key] = null
-    }
-    if (expectsCSS) {
-      removeTransitionClass(el, leaveToClass)
-      removeTransitionClass(el, leaveActiveClass)
-    }
-    if (cb.cancelled) {
-      if (expectsCSS) {
-        removeTransitionClass(el, leaveClass)
-      }
-      leaveCancelled && leaveCancelled(el)
-    } else {
-      rm()
-      afterLeave && afterLeave(el)
-    }
-    el._leaveCb = null
-  })
-
-  if (delayLeave) {
-    delayLeave(performLeave)
-  } else {
-    performLeave()
-  }
-
-  function performLeave () {
-    // the delayed leave may have already been cancelled
-    if (cb.cancelled) {
-      return
-    }
-    // record leaving element
-    if (!vnode.data.show && el.parentNode) {
-      (el.parentNode._pending || (el.parentNode._pending = {}))[(vnode.key: any)] = vnode
-    }
-    beforeLeave && beforeLeave(el)
-    if (expectsCSS) {
-      addTransitionClass(el, leaveClass)
-      addTransitionClass(el, leaveActiveClass)
-      nextFrame(() => {
-        removeTransitionClass(el, leaveClass)
-        if (!cb.cancelled) {
-          addTransitionClass(el, leaveToClass)
-          if (!userWantsControl) {
-            if (isValidDuration(explicitLeaveDuration)) {
-              setTimeout(cb, explicitLeaveDuration)
-            } else {
-              whenTransitionEnds(el, type, cb)
-            }
-          }
-        }
-      })
-    }
-    leave && leave(el, cb)
-    if (!expectsCSS && !userWantsControl) {
-      cb()
-    }
-  }
-}
-
-// only used in dev mode
-function checkDuration (val, name, vnode) {
-  if (typeof val !== 'number') {
-    warn(
-      `<transition> explicit ${name} duration is not a valid number - ` +
-      `got ${JSON.stringify(val)}.`,
-      vnode.context
-    )
-  } else if (isNaN(val)) {
-    warn(
-      `<transition> explicit ${name} duration is NaN - ` +
-      'the duration expression might be incorrect.',
-      vnode.context
-    )
-  }
-}
-
-function isValidDuration (val) {
-  return typeof val === 'number' && !isNaN(val)
-}
-
-/**
- * Normalize a transition hook's argument length. The hook may be:
- * - a merged hook (invoker) with the original in .fns
- * - a wrapped component method (check ._length)
- * - a plain function (.length)
- */
-function getHookArgumentsLength (fn: Function): boolean {
-  if (isUndef(fn)) {
-    return false
-  }
-  const invokerFns = fn.fns
-  if (isDef(invokerFns)) {
-    // invoker
-    return getHookArgumentsLength(
-      Array.isArray(invokerFns)
-        ? invokerFns[0]
-        : invokerFns
-    )
-  } else {
-    return (fn._length || fn.length) > 1
-  }
-}
-
-function _enter (_: any, vnode: VNodeWithData) {
-  if (vnode.data.show !== true) {
-    enter(vnode)
-  }
-}
-
-export default inBrowser ? {
-  create: _enter,
-  activate: _enter,
-  remove (vnode: VNode, rm: Function) {
-    /* istanbul ignore else */
-    if (vnode.data.show !== true) {
-      leave(vnode, rm)
-    } else {
-      rm()
-    }
-  }
-} : {}
diff --git a/1.Vue/src/platforms/web/runtime/node-ops.js b/1.Vue/src/platforms/web/runtime/node-ops.js
deleted file mode 100644
index 3a2978a..0000000
--- a/1.Vue/src/platforms/web/runtime/node-ops.js
+++ /dev/null
@@ -1,59 +0,0 @@
-/* @flow */
-
-import { namespaceMap } from 'web/util/index'
-
-export function createElement (tagName: string, vnode: VNode): Element {
-  const elm = document.createElement(tagName)
-  if (tagName !== 'select') {
-    return elm
-  }
-  // false or null will remove the attribute but undefined will not
-  if (vnode.data && vnode.data.attrs && vnode.data.attrs.multiple !== undefined) {
-    elm.setAttribute('multiple', 'multiple')
-  }
-  return elm
-}
-
-export function createElementNS (namespace: string, tagName: string): Element {
-  return document.createElementNS(namespaceMap[namespace], tagName)
-}
-
-export function createTextNode (text: string): Text {
-  return document.createTextNode(text)
-}
-
-export function createComment (text: string): Comment {
-  return document.createComment(text)
-}
-
-export function insertBefore (parentNode: Node, newNode: Node, referenceNode: Node) {
-  parentNode.insertBefore(newNode, referenceNode)
-}
-
-export function removeChild (node: Node, child: Node) {
-  node.removeChild(child)
-}
-
-export function appendChild (node: Node, child: Node) {
-  node.appendChild(child)
-}
-
-export function parentNode (node: Node): ?Node {
-  return node.parentNode
-}
-
-export function nextSibling (node: Node): ?Node {
-  return node.nextSibling
-}
-
-export function tagName (node: Element): string {
-  return node.tagName
-}
-
-export function setTextContent (node: Node, text: string) {
-  node.textContent = text
-}
-
-export function setStyleScope (node: Element, scopeId: string) {
-  node.setAttribute(scopeId, '')
-}
diff --git a/1.Vue/src/platforms/web/runtime/patch.js b/1.Vue/src/platforms/web/runtime/patch.js
deleted file mode 100644
index d982afe..0000000
--- a/1.Vue/src/platforms/web/runtime/patch.js
+++ /dev/null
@@ -1,12 +0,0 @@
-/* @flow */
-
-import * as nodeOps from 'web/runtime/node-ops'
-import { createPatchFunction } from 'core/vdom/patch'
-import baseModules from 'core/vdom/modules/index'
-import platformModules from 'web/runtime/modules/index'
-
-// the directive module should be applied last, after all
-// built-in modules have been applied.
-const modules = platformModules.concat(baseModules)
-
-export const patch: Function = createPatchFunction({ nodeOps, modules })
diff --git a/1.Vue/src/platforms/web/runtime/transition-util.js b/1.Vue/src/platforms/web/runtime/transition-util.js
deleted file mode 100644
index 0885f97..0000000
--- a/1.Vue/src/platforms/web/runtime/transition-util.js
+++ /dev/null
@@ -1,190 +0,0 @@
-/* @flow */
-
-import { inBrowser, isIE9 } from 'core/util/index'
-import { addClass, removeClass } from './class-util'
-import { remove, extend, cached } from 'shared/util'
-
-export function resolveTransition (def?: string | Object): ?Object {
-  if (!def) {
-    return
-  }
-  /* istanbul ignore else */
-  if (typeof def === 'object') {
-    const res = {}
-    if (def.css !== false) {
-      extend(res, autoCssTransition(def.name || 'v'))
-    }
-    extend(res, def)
-    return res
-  } else if (typeof def === 'string') {
-    return autoCssTransition(def)
-  }
-}
-
-const autoCssTransition: (name: string) => Object = cached(name => {
-  return {
-    enterClass: `${name}-enter`,
-    enterToClass: `${name}-enter-to`,
-    enterActiveClass: `${name}-enter-active`,
-    leaveClass: `${name}-leave`,
-    leaveToClass: `${name}-leave-to`,
-    leaveActiveClass: `${name}-leave-active`
-  }
-})
-
-export const hasTransition = inBrowser && !isIE9
-const TRANSITION = 'transition'
-const ANIMATION = 'animation'
-
-// Transition property/event sniffing
-export let transitionProp = 'transition'
-export let transitionEndEvent = 'transitionend'
-export let animationProp = 'animation'
-export let 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
-const raf = inBrowser
-  ? window.requestAnimationFrame
-    ? window.requestAnimationFrame.bind(window)
-    : setTimeout
-  : /* istanbul ignore next */ fn => fn()
-
-export function nextFrame (fn: Function) {
-  raf(() => {
-    raf(fn)
-  })
-}
-
-export function addTransitionClass (el: any, cls: string) {
-  const transitionClasses = el._transitionClasses || (el._transitionClasses = [])
-  if (transitionClasses.indexOf(cls) < 0) {
-    transitionClasses.push(cls)
-    addClass(el, cls)
-  }
-}
-
-export function removeTransitionClass (el: any, cls: string) {
-  if (el._transitionClasses) {
-    remove(el._transitionClasses, cls)
-  }
-  removeClass(el, cls)
-}
-
-export function whenTransitionEnds (
-  el: Element,
-  expectedType: ?string,
-  cb: Function
-) {
-  const { type, timeout, propCount } = getTransitionInfo(el, expectedType)
-  if (!type) return cb()
-  const event: string = type === TRANSITION ? transitionEndEvent : animationEndEvent
-  let ended = 0
-  const end = () => {
-    el.removeEventListener(event, onEnd)
-    cb()
-  }
-  const onEnd = e => {
-    if (e.target === el) {
-      if (++ended >= propCount) {
-        end()
-      }
-    }
-  }
-  setTimeout(() => {
-    if (ended < propCount) {
-      end()
-    }
-  }, timeout + 1)
-  el.addEventListener(event, onEnd)
-}
-
-const transformRE = /\b(transform|all)(,|$)/
-
-export function getTransitionInfo (el: Element, expectedType?: ?string): {
-  type: ?string;
-  propCount: number;
-  timeout: number;
-  hasTransform: boolean;
-} {
-  const styles: any = window.getComputedStyle(el)
-  // JSDOM may return undefined for transition properties
-  const transitionDelays: Array<string> = (styles[transitionProp + 'Delay'] || '').split(', ')
-  const transitionDurations: Array<string> = (styles[transitionProp + 'Duration'] || '').split(', ')
-  const transitionTimeout: number = getTimeout(transitionDelays, transitionDurations)
-  const animationDelays: Array<string> = (styles[animationProp + 'Delay'] || '').split(', ')
-  const animationDurations: Array<string> = (styles[animationProp + 'Duration'] || '').split(', ')
-  const animationTimeout: number = getTimeout(animationDelays, animationDurations)
-
-  let type: ?string
-  let timeout = 0
-  let 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
-  }
-  const hasTransform: boolean =
-    type === TRANSITION &&
-    transformRE.test(styles[transitionProp + 'Property'])
-  return {
-    type,
-    timeout,
-    propCount,
-    hasTransform
-  }
-}
-
-function getTimeout (delays: Array<string>, durations: Array<string>): number {
-  /* istanbul ignore next */
-  while (delays.length < durations.length) {
-    delays = delays.concat(delays)
-  }
-
-  return Math.max.apply(null, durations.map((d, i) => {
-    return toMs(d) + toMs(delays[i])
-  }))
-}
-
-// Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
-// in a locale-dependent way, using a comma instead of a dot.
-// If comma is not replaced with a dot, the input will be rounded down (i.e. acting
-// as a floor function) causing unexpected behaviors
-function toMs (s: string): number {
-  return Number(s.slice(0, -1).replace(',', '.')) * 1000
-}
diff --git a/1.Vue/src/platforms/web/server/compiler.js b/1.Vue/src/platforms/web/server/compiler.js
deleted file mode 100644
index 20e5736..0000000
--- a/1.Vue/src/platforms/web/server/compiler.js
+++ /dev/null
@@ -1,11 +0,0 @@
-/* @flow */
-
-import { baseOptions } from '../compiler/options'
-import { createCompiler } from 'server/optimizing-compiler/index'
-
-const { compile, compileToFunctions } = createCompiler(baseOptions)
-
-export {
-  compile as ssrCompile,
-  compileToFunctions as ssrCompileToFunctions
-}
diff --git a/1.Vue/src/platforms/web/server/directives/index.js b/1.Vue/src/platforms/web/server/directives/index.js
deleted file mode 100644
index fd7fce0..0000000
--- a/1.Vue/src/platforms/web/server/directives/index.js
+++ /dev/null
@@ -1,7 +0,0 @@
-import show from './show'
-import model from './model'
-
-export default {
-  show,
-  model
-}
diff --git a/1.Vue/src/platforms/web/server/directives/model.js b/1.Vue/src/platforms/web/server/directives/model.js
deleted file mode 100644
index 7962d6c..0000000
--- a/1.Vue/src/platforms/web/server/directives/model.js
+++ /dev/null
@@ -1,44 +0,0 @@
-/* @flow */
-
-import { looseEqual, looseIndexOf } from 'shared/util'
-
-// this is only applied for <select v-model> because it is the only edge case
-// that must be done at runtime instead of compile time.
-export default function model (node: VNodeWithData, dir: VNodeDirective) {
-  if (!node.children) return
-  const value = dir.value
-  const isMultiple = node.data.attrs && node.data.attrs.multiple
-  for (let i = 0, l = node.children.length; i < l; i++) {
-    const option = node.children[i]
-    if (option.tag === 'option') {
-      if (isMultiple) {
-        const selected =
-          Array.isArray(value) &&
-          (looseIndexOf(value, getValue(option)) > -1)
-        if (selected) {
-          setSelected(option)
-        }
-      } else {
-        if (looseEqual(value, getValue(option))) {
-          setSelected(option)
-          return
-        }
-      }
-    }
-  }
-}
-
-function getValue (option) {
-  const data = option.data || {}
-  return (
-    (data.attrs && data.attrs.value) ||
-    (data.domProps && data.domProps.value) ||
-    (option.children && option.children[0] && option.children[0].text)
-  )
-}
-
-function setSelected (option) {
-  const data = option.data || (option.data = {})
-  const attrs = data.attrs || (data.attrs = {})
-  attrs.selected = ''
-}
diff --git a/1.Vue/src/platforms/web/server/directives/show.js b/1.Vue/src/platforms/web/server/directives/show.js
deleted file mode 100644
index 7493b27..0000000
--- a/1.Vue/src/platforms/web/server/directives/show.js
+++ /dev/null
@@ -1,12 +0,0 @@
-/* @flow */
-
-export default function show (node: VNodeWithData, dir: VNodeDirective) {
-  if (!dir.value) {
-    const style: any = node.data.style || (node.data.style = {})
-    if (Array.isArray(style)) {
-      style.push({ display: 'none' })
-    } else {
-      style.display = 'none'
-    }
-  }
-}
diff --git a/1.Vue/src/platforms/web/server/modules/attrs.js b/1.Vue/src/platforms/web/server/modules/attrs.js
deleted file mode 100644
index 4d48eee..0000000
--- a/1.Vue/src/platforms/web/server/modules/attrs.js
+++ /dev/null
@@ -1,63 +0,0 @@
-/* @flow */
-
-import { escape } from '../util'
-
-import {
-  isDef,
-  isUndef,
-  extend
-} from 'shared/util'
-
-import {
-  isBooleanAttr,
-  isEnumeratedAttr,
-  isFalsyAttrValue,
-  convertEnumeratedValue
-} from 'web/util/attrs'
-
-import { isSSRUnsafeAttr } from 'web/server/util'
-
-export default function renderAttrs (node: VNodeWithData): string {
-  let attrs = node.data.attrs
-  let res = ''
-
-  const opts = node.parent && node.parent.componentOptions
-  if (isUndef(opts) || opts.Ctor.options.inheritAttrs !== false) {
-    let parent = node.parent
-    while (isDef(parent)) {
-      if (isDef(parent.data) && isDef(parent.data.attrs)) {
-        attrs = extend(extend({}, attrs), parent.data.attrs)
-      }
-      parent = parent.parent
-    }
-  }
-
-  if (isUndef(attrs)) {
-    return res
-  }
-
-  for (const key in attrs) {
-    if (isSSRUnsafeAttr(key)) {
-      continue
-    }
-    if (key === 'style') {
-      // leave it to the style module
-      continue
-    }
-    res += renderAttr(key, attrs[key])
-  }
-  return res
-}
-
-export function renderAttr (key: string, value: string): string {
-  if (isBooleanAttr(key)) {
-    if (!isFalsyAttrValue(value)) {
-      return ` ${key}="${key}"`
-    }
-  } else if (isEnumeratedAttr(key)) {
-    return ` ${key}="${escape(convertEnumeratedValue(key, value))}"`
-  } else if (!isFalsyAttrValue(value)) {
-    return ` ${key}="${escape(String(value))}"`
-  }
-  return ''
-}
diff --git a/1.Vue/src/platforms/web/server/modules/class.js b/1.Vue/src/platforms/web/server/modules/class.js
deleted file mode 100644
index c19040e..0000000
--- a/1.Vue/src/platforms/web/server/modules/class.js
+++ /dev/null
@@ -1,11 +0,0 @@
-/* @flow */
-
-import { escape } from '../util'
-import { genClassForVnode } from 'web/util/index'
-
-export default function renderClass (node: VNodeWithData): ?string {
-  const classList = genClassForVnode(node)
-  if (classList !== '') {
-    return ` class="${escape(classList)}"`
-  }
-}
diff --git a/1.Vue/src/platforms/web/server/modules/dom-props.js b/1.Vue/src/platforms/web/server/modules/dom-props.js
deleted file mode 100644
index 57c18ee..0000000
--- a/1.Vue/src/platforms/web/server/modules/dom-props.js
+++ /dev/null
@@ -1,50 +0,0 @@
-/* @flow */
-
-import VNode from 'core/vdom/vnode'
-import { renderAttr } from './attrs'
-import { isDef, isUndef, extend } from 'shared/util'
-import { propsToAttrMap, isRenderableAttr } from '../util'
-
-export default function renderDOMProps (node: VNodeWithData): string {
-  let props = node.data.domProps
-  let res = ''
-
-  let parent = node.parent
-  while (isDef(parent)) {
-    if (parent.data && parent.data.domProps) {
-      props = extend(extend({}, props), parent.data.domProps)
-    }
-    parent = parent.parent
-  }
-
-  if (isUndef(props)) {
-    return res
-  }
-
-  const attrs = node.data.attrs
-  for (const key in props) {
-    if (key === 'innerHTML') {
-      setText(node, props[key], true)
-    } else if (key === 'textContent') {
-      setText(node, props[key], false)
-    } else if (key === 'value' && node.tag === 'textarea') {
-      setText(node, props[key], false)
-    } else {
-      // $flow-disable-line (WTF?)
-      const attr = propsToAttrMap[key] || key.toLowerCase()
-      if (isRenderableAttr(attr) &&
-        // avoid rendering double-bound props/attrs twice
-        !(isDef(attrs) && isDef(attrs[attr]))
-      ) {
-        res += renderAttr(attr, props[key])
-      }
-    }
-  }
-  return res
-}
-
-function setText (node, text, raw) {
-  const child = new VNode(undefined, undefined, undefined, text)
-  child.raw = raw
-  node.children = [child]
-}
diff --git a/1.Vue/src/platforms/web/server/modules/index.js b/1.Vue/src/platforms/web/server/modules/index.js
deleted file mode 100644
index 3d15bc5..0000000
--- a/1.Vue/src/platforms/web/server/modules/index.js
+++ /dev/null
@@ -1,11 +0,0 @@
-import attrs from './attrs'
-import domProps from './dom-props'
-import klass from './class'
-import style from './style'
-
-export default [
-  attrs,
-  domProps,
-  klass,
-  style
-]
diff --git a/1.Vue/src/platforms/web/server/modules/style.js b/1.Vue/src/platforms/web/server/modules/style.js
deleted file mode 100644
index 4c7c2bb..0000000
--- a/1.Vue/src/platforms/web/server/modules/style.js
+++ /dev/null
@@ -1,41 +0,0 @@
-/* @flow */
-
-import { escape, noUnitNumericStyleProps } from '../util'
-import { hyphenate } from 'shared/util'
-import { getStyle } from 'web/util/style'
-
-export function genStyle (style: Object): string {
-  let styleText = ''
-  for (const key in style) {
-    const value = style[key]
-    const hyphenatedKey = hyphenate(key)
-    if (Array.isArray(value)) {
-      for (let i = 0, len = value.length; i < len; i++) {
-        styleText += normalizeValue(hyphenatedKey, value[i])
-      }
-    } else {
-      styleText += normalizeValue(hyphenatedKey, value)
-    }
-  }
-  return styleText
-}
-
-function normalizeValue(key: string, value: any): string {
-  if (
-    typeof value === 'string' ||
-    (typeof value === 'number' && noUnitNumericStyleProps[key]) ||
-    value === 0
-  ) {
-    return `${key}:${value};`
-  } else {
-    // invalid values
-    return ``
-  }
-}
-
-export default function renderStyle (vnode: VNodeWithData): ?string {
-  const styleText = genStyle(getStyle(vnode, false))
-  if (styleText !== '') {
-    return ` style=${JSON.stringify(escape(styleText))}`
-  }
-}
diff --git a/1.Vue/src/platforms/web/server/util.js b/1.Vue/src/platforms/web/server/util.js
deleted file mode 100644
index 1981d00..0000000
--- a/1.Vue/src/platforms/web/server/util.js
+++ /dev/null
@@ -1,101 +0,0 @@
-/* @flow */
-
-import { makeMap } from 'shared/util'
-
-const isAttr = makeMap(
-  'accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
-  'autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,' +
-  'checked,cite,class,code,codebase,color,cols,colspan,content,http-equiv,' +
-  'name,contenteditable,contextmenu,controls,coords,data,datetime,default,' +
-  'defer,dir,dirname,disabled,download,draggable,dropzone,enctype,method,for,' +
-  'form,formaction,headers,height,hidden,high,href,hreflang,http-equiv,' +
-  'icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,' +
-  'manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,' +
-  'muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,' +
-  'preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,' +
-  'scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,' +
-  'spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,' +
-  'target,title,type,usemap,value,width,wrap'
-)
-
-const unsafeAttrCharRE = /[>/="'\u0009\u000a\u000c\u0020]/ // eslint-disable-line no-control-regex
-export const isSSRUnsafeAttr = (name: string): boolean => {
-  return unsafeAttrCharRE.test(name)
-}
-
-/* istanbul ignore next */
-const isRenderableAttr = (name: string): boolean => {
-  return (
-    isAttr(name) ||
-    name.indexOf('data-') === 0 ||
-    name.indexOf('aria-') === 0
-  )
-}
-export { isRenderableAttr }
-
-export const propsToAttrMap = {
-  acceptCharset: 'accept-charset',
-  className: 'class',
-  htmlFor: 'for',
-  httpEquiv: 'http-equiv'
-}
-
-const ESC = {
-  '<': '&lt;',
-  '>': '&gt;',
-  '"': '&quot;',
-  '&': '&amp;'
-}
-
-export function escape (s: string) {
-  return s.replace(/[<>"&]/g, escapeChar)
-}
-
-function escapeChar (a) {
-  return ESC[a] || a
-}
-
-export const noUnitNumericStyleProps = {
-  "animation-iteration-count": true,
-  "border-image-outset": true,
-  "border-image-slice": true,
-  "border-image-width": true,
-  "box-flex": true,
-  "box-flex-group": true,
-  "box-ordinal-group": true,
-  "column-count": true,
-  "columns": true,
-  "flex": true,
-  "flex-grow": true,
-  "flex-positive": true,
-  "flex-shrink": true,
-  "flex-negative": true,
-  "flex-order": true,
-  "grid-row": true,
-  "grid-row-end": true,
-  "grid-row-span": true,
-  "grid-row-start": true,
-  "grid-column": true,
-  "grid-column-end": true,
-  "grid-column-span": true,
-  "grid-column-start": true,
-  "font-weight": true,
-  "line-clamp": true,
-  "line-height": true,
-  "opacity": true,
-  "order": true,
-  "orphans": true,
-  "tab-size": true,
-  "widows": true,
-  "z-index": true,
-  "zoom": true,
-  // SVG
-  "fill-opacity": true,
-  "flood-opacity": true,
-  "stop-opacity": true,
-  "stroke-dasharray": true,
-  "stroke-dashoffset": true,
-  "stroke-miterlimit": true,
-  "stroke-opacity": true,
-  "stroke-width": true
-}
diff --git a/1.Vue/src/platforms/web/util/attrs.js b/1.Vue/src/platforms/web/util/attrs.js
deleted file mode 100644
index fea9fb9..0000000
--- a/1.Vue/src/platforms/web/util/attrs.js
+++ /dev/null
@@ -1,54 +0,0 @@
-/* @flow */
-
-import { makeMap } from 'shared/util'
-
-// these are reserved for web because they are directly compiled away
-// during template compilation
-export const isReservedAttr = makeMap('style,class')
-
-// attributes that should be using props for binding
-const acceptValue = makeMap('input,textarea,option,select,progress')
-export const mustUseProp = (tag: string, type: ?string, attr: string): boolean => {
-  return (
-    (attr === 'value' && acceptValue(tag)) && type !== 'button' ||
-    (attr === 'selected' && tag === 'option') ||
-    (attr === 'checked' && tag === 'input') ||
-    (attr === 'muted' && tag === 'video')
-  )
-}
-
-export const isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck')
-
-const isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only')
-
-export const convertEnumeratedValue = (key: string, value: any) => {
-  return isFalsyAttrValue(value) || value === 'false'
-    ? 'false'
-    // allow arbitrary string value for contenteditable
-    : key === 'contenteditable' && isValidContentEditableValue(value)
-      ? value
-      : 'true'
-}
-
-export const isBooleanAttr = makeMap(
-  'allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
-  'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
-  'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
-  'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
-  'required,reversed,scoped,seamless,selected,sortable,translate,' +
-  'truespeed,typemustmatch,visible'
-)
-
-export const xlinkNS = 'http://www.w3.org/1999/xlink'
-
-export const isXlink = (name: string): boolean => {
-  return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink'
-}
-
-export const getXlinkProp = (name: string): string => {
-  return isXlink(name) ? name.slice(6, name.length) : ''
-}
-
-export const isFalsyAttrValue = (val: any): boolean => {
-  return val == null || val === false
-}
diff --git a/1.Vue/src/platforms/web/util/class.js b/1.Vue/src/platforms/web/util/class.js
deleted file mode 100644
index 542dcbc..0000000
--- a/1.Vue/src/platforms/web/util/class.js
+++ /dev/null
@@ -1,85 +0,0 @@
-/* @flow */
-
-import { isDef, isObject } from 'shared/util'
-
-export function genClassForVnode (vnode: VNodeWithData): string {
-  let data = vnode.data
-  let parentNode = vnode
-  let childNode = vnode
-  while (isDef(childNode.componentInstance)) {
-    childNode = childNode.componentInstance._vnode
-    if (childNode && childNode.data) {
-      data = mergeClassData(childNode.data, data)
-    }
-  }
-  while (isDef(parentNode = parentNode.parent)) {
-    if (parentNode && parentNode.data) {
-      data = mergeClassData(data, parentNode.data)
-    }
-  }
-  return renderClass(data.staticClass, data.class)
-}
-
-function mergeClassData (child: VNodeData, parent: VNodeData): {
-  staticClass: string,
-  class: any
-} {
-  return {
-    staticClass: concat(child.staticClass, parent.staticClass),
-    class: isDef(child.class)
-      ? [child.class, parent.class]
-      : parent.class
-  }
-}
-
-export function renderClass (
-  staticClass: ?string,
-  dynamicClass: any
-): string {
-  if (isDef(staticClass) || isDef(dynamicClass)) {
-    return concat(staticClass, stringifyClass(dynamicClass))
-  }
-  /* istanbul ignore next */
-  return ''
-}
-
-export function concat (a: ?string, b: ?string): string {
-  return a ? b ? (a + ' ' + b) : a : (b || '')
-}
-
-export function stringifyClass (value: any): string {
-  if (Array.isArray(value)) {
-    return stringifyArray(value)
-  }
-  if (isObject(value)) {
-    return stringifyObject(value)
-  }
-  if (typeof value === 'string') {
-    return value
-  }
-  /* istanbul ignore next */
-  return ''
-}
-
-function stringifyArray (value: Array<any>): string {
-  let res = ''
-  let stringified
-  for (let i = 0, l = value.length; i < l; i++) {
-    if (isDef(stringified = stringifyClass(value[i])) && stringified !== '') {
-      if (res) res += ' '
-      res += stringified
-    }
-  }
-  return res
-}
-
-function stringifyObject (value: Object): string {
-  let res = ''
-  for (const key in value) {
-    if (value[key]) {
-      if (res) res += ' '
-      res += key
-    }
-  }
-  return res
-}
diff --git a/1.Vue/src/platforms/web/util/compat.js b/1.Vue/src/platforms/web/util/compat.js
deleted file mode 100644
index d95759c..0000000
--- a/1.Vue/src/platforms/web/util/compat.js
+++ /dev/null
@@ -1,16 +0,0 @@
-/* @flow */
-
-import { inBrowser } from 'core/util/index'
-
-// check whether current browser encodes a char inside attribute values
-let div
-function getShouldDecode (href: boolean): boolean {
-  div = div || document.createElement('div')
-  div.innerHTML = href ? `<a href="\n"/>` : `<div a="\n"/>`
-  return div.innerHTML.indexOf('&#10;') > 0
-}
-
-// #3663: IE encodes newlines inside attribute values while other browsers don't
-export const shouldDecodeNewlines = inBrowser ? getShouldDecode(false) : false
-// #6828: chrome encodes content in a[href]
-export const shouldDecodeNewlinesForHref = inBrowser ? getShouldDecode(true) : false
diff --git a/1.Vue/src/platforms/web/util/element.js b/1.Vue/src/platforms/web/util/element.js
deleted file mode 100644
index 65f1aaf..0000000
--- a/1.Vue/src/platforms/web/util/element.js
+++ /dev/null
@@ -1,77 +0,0 @@
-/* @flow */
-
-import { inBrowser } from 'core/util/env'
-import { makeMap } from 'shared/util'
-
-export const namespaceMap = {
-  svg: 'http://www.w3.org/2000/svg',
-  math: 'http://www.w3.org/1998/Math/MathML'
-}
-
-export const isHTMLTag = makeMap(
-  'html,body,base,head,link,meta,style,title,' +
-  'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
-  'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
-  'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
-  's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
-  'embed,object,param,source,canvas,script,noscript,del,ins,' +
-  'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
-  'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
-  'output,progress,select,textarea,' +
-  'details,dialog,menu,menuitem,summary,' +
-  'content,element,shadow,template,blockquote,iframe,tfoot'
-)
-
-// this map is intentionally selective, only covering SVG elements that may
-// contain child elements.
-export const isSVG = makeMap(
-  'svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
-  'foreignObject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
-  'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view',
-  true
-)
-
-export const isPreTag = (tag: ?string): boolean => tag === 'pre'
-
-export const isReservedTag = (tag: string): ?boolean => {
-  return isHTMLTag(tag) || isSVG(tag)
-}
-
-export function getTagNamespace (tag: string): ?string {
-  if (isSVG(tag)) {
-    return 'svg'
-  }
-  // basic support for MathML
-  // note it doesn't support other MathML elements being component roots
-  if (tag === 'math') {
-    return 'math'
-  }
-}
-
-const unknownElementCache = Object.create(null)
-export function isUnknownElement (tag: string): boolean {
-  /* istanbul ignore if */
-  if (!inBrowser) {
-    return true
-  }
-  if (isReservedTag(tag)) {
-    return false
-  }
-  tag = tag.toLowerCase()
-  /* istanbul ignore if */
-  if (unknownElementCache[tag] != null) {
-    return unknownElementCache[tag]
-  }
-  const el = document.createElement(tag)
-  if (tag.indexOf('-') > -1) {
-    // http://stackoverflow.com/a/28210364/1070244
-    return (unknownElementCache[tag] = (
-      el.constructor === window.HTMLUnknownElement ||
-      el.constructor === window.HTMLElement
-    ))
-  } else {
-    return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()))
-  }
-}
-
-export const isTextInputType = makeMap('text,number,password,search,email,tel,url')
diff --git a/1.Vue/src/platforms/web/util/index.js b/1.Vue/src/platforms/web/util/index.js
deleted file mode 100644
index da5e46e..0000000
--- a/1.Vue/src/platforms/web/util/index.js
+++ /dev/null
@@ -1,25 +0,0 @@
-/* @flow */
-
-import { warn } from 'core/util/index'
-
-export * from './attrs'
-export * from './class'
-export * from './element'
-
-/**
- * Query an element selector if it's not an element already.
- */
-export function query (el: string | Element): Element {
-  if (typeof el === 'string') {
-    const selected = document.querySelector(el)
-    if (!selected) {
-      process.env.NODE_ENV !== 'production' && warn(
-        'Cannot find element: ' + el
-      )
-      return document.createElement('div')
-    }
-    return selected
-  } else {
-    return el
-  }
-}
diff --git a/1.Vue/src/platforms/web/util/style.js b/1.Vue/src/platforms/web/util/style.js
deleted file mode 100644
index 46e69e4..0000000
--- a/1.Vue/src/platforms/web/util/style.js
+++ /dev/null
@@ -1,71 +0,0 @@
-/* @flow */
-
-import { cached, extend, toObject } from 'shared/util'
-
-export const parseStyleText = cached(function (cssText) {
-  const res = {}
-  const listDelimiter = /;(?![^(]*\))/g
-  const propertyDelimiter = /:(.+)/
-  cssText.split(listDelimiter).forEach(function (item) {
-    if (item) {
-      const 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: VNodeData): ?Object {
-  const 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
-export function normalizeStyleBinding (bindingStyle: any): ?Object {
-  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
- */
-export function getStyle (vnode: VNodeWithData, checkChild: boolean): Object {
-  const res = {}
-  let styleData
-
-  if (checkChild) {
-    let childNode = vnode
-    while (childNode.componentInstance) {
-      childNode = childNode.componentInstance._vnode
-      if (
-        childNode && childNode.data &&
-        (styleData = normalizeStyleData(childNode.data))
-      ) {
-        extend(res, styleData)
-      }
-    }
-  }
-
-  if ((styleData = normalizeStyleData(vnode.data))) {
-    extend(res, styleData)
-  }
-
-  let parentNode = vnode
-  while ((parentNode = parentNode.parent)) {
-    if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
-      extend(res, styleData)
-    }
-  }
-  return res
-}
diff --git a/1.Vue/src/platforms/weex/compiler/directives/index.js b/1.Vue/src/platforms/weex/compiler/directives/index.js
deleted file mode 100644
index 12ced22..0000000
--- a/1.Vue/src/platforms/weex/compiler/directives/index.js
+++ /dev/null
@@ -1,5 +0,0 @@
-import model from './model'
-
-export default {
-  model
-}
diff --git a/1.Vue/src/platforms/weex/compiler/directives/model.js b/1.Vue/src/platforms/weex/compiler/directives/model.js
deleted file mode 100644
index 6961802..0000000
--- a/1.Vue/src/platforms/weex/compiler/directives/model.js
+++ /dev/null
@@ -1,33 +0,0 @@
-/* @flow */
-
-import { addHandler, addAttr } from 'compiler/helpers'
-import { genComponentModel, genAssignmentCode } from 'compiler/directives/model'
-
-export default function model (
-  el: ASTElement,
-  dir: ASTDirective
-): ?boolean {
-  if (el.tag === 'input' || el.tag === 'textarea') {
-    genDefaultModel(el, dir.value, dir.modifiers)
-  } else {
-    genComponentModel(el, dir.value, dir.modifiers)
-  }
-}
-
-function genDefaultModel (
-  el: ASTElement,
-  value: string,
-  modifiers: ?ASTModifiers
-): ?boolean {
-  const { lazy, trim, number } = modifiers || {}
-  const event = lazy ? 'change' : 'input'
-
-  let valueExpression = `$event.target.attr.value${trim ? '.trim()' : ''}`
-  if (number) {
-    valueExpression = `_n(${valueExpression})`
-  }
-
-  const code = genAssignmentCode(value, valueExpression)
-  addAttr(el, 'value', `(${value})`)
-  addHandler(el, event, code, null, true)
-}
diff --git a/1.Vue/src/platforms/weex/compiler/index.js b/1.Vue/src/platforms/weex/compiler/index.js
deleted file mode 100644
index 94f350b..0000000
--- a/1.Vue/src/platforms/weex/compiler/index.js
+++ /dev/null
@@ -1,52 +0,0 @@
-/* @flow */
-
-import { genStaticKeys } from 'shared/util'
-import { createCompiler } from 'compiler/index'
-
-import modules from './modules/index'
-import directives from './directives/index'
-
-import {
-  isUnaryTag,
-  mustUseProp,
-  isReservedTag,
-  canBeLeftOpenTag,
-  getTagNamespace
-} from '../util/element'
-
-export const baseOptions: WeexCompilerOptions = {
-  modules,
-  directives,
-  isUnaryTag,
-  mustUseProp,
-  canBeLeftOpenTag,
-  isReservedTag,
-  getTagNamespace,
-  preserveWhitespace: false,
-  recyclable: false,
-  staticKeys: genStaticKeys(modules)
-}
-
-const compiler = createCompiler(baseOptions)
-
-export function compile (
-  template: string,
-  options?: WeexCompilerOptions
-): WeexCompiledResult {
-  let generateAltRender = false
-  if (options && options.recyclable === true) {
-    generateAltRender = true
-    options.recyclable = false
-  }
-  const result = compiler.compile(template, options)
-
-  // generate @render function for <recycle-list>
-  if (options && generateAltRender) {
-    options.recyclable = true
-    // disable static optimizations
-    options.optimize = false
-    const { render } = compiler.compile(template, options)
-    result['@render'] = render
-  }
-  return result
-}
diff --git a/1.Vue/src/platforms/weex/compiler/modules/append.js b/1.Vue/src/platforms/weex/compiler/modules/append.js
deleted file mode 100644
index b2c9817..0000000
--- a/1.Vue/src/platforms/weex/compiler/modules/append.js
+++ /dev/null
@@ -1,27 +0,0 @@
-/* @flow */
-
-import { makeMap } from 'shared/util'
-
-// The "unitary tag" means that the tag node and its children
-// must be sent to the native together.
-const isUnitaryTag = makeMap('cell,header,cell-slot,recycle-list', true)
-
-function preTransformNode (el: ASTElement) {
-  if (isUnitaryTag(el.tag) && !el.attrsList.some(item => item.name === 'append')) {
-    el.attrsMap.append = 'tree'
-    el.attrsList.push({ name: 'append', value: 'tree' })
-  }
-  if (el.attrsMap.append === 'tree') {
-    el.appendAsTree = true
-  }
-}
-
-function genData (el: ASTElement): string {
-  return el.appendAsTree ? `appendAsTree:true,` : ''
-}
-
-export default {
-  staticKeys: ['appendAsTree'],
-  preTransformNode,
-  genData
-}
diff --git a/1.Vue/src/platforms/weex/compiler/modules/class.js b/1.Vue/src/platforms/weex/compiler/modules/class.js
deleted file mode 100644
index 05a0182..0000000
--- a/1.Vue/src/platforms/weex/compiler/modules/class.js
+++ /dev/null
@@ -1,74 +0,0 @@
-/* @flow */
-
-import { parseText } from 'compiler/parser/text-parser'
-import {
-  getAndRemoveAttr,
-  getBindingAttr,
-  baseWarn
-} from 'compiler/helpers'
-
-type StaticClassResult = {
-  dynamic: boolean,
-  classResult: string
-};
-
-function transformNode (el: ASTElement, options: CompilerOptions) {
-  const warn = options.warn || baseWarn
-  const staticClass = getAndRemoveAttr(el, 'class')
-  const { dynamic, classResult } = parseStaticClass(staticClass, options)
-  if (process.env.NODE_ENV !== 'production' && dynamic && staticClass) {
-    warn(
-      `class="${staticClass}": ` +
-      'Interpolation inside attributes has been deprecated. ' +
-      'Use v-bind or the colon shorthand instead.',
-      el.rawAttrsMap['class']
-    )
-  }
-  if (!dynamic && classResult) {
-    el.staticClass = classResult
-  }
-  const classBinding = getBindingAttr(el, 'class', false /* getStatic */)
-  if (classBinding) {
-    el.classBinding = classBinding
-  } else if (dynamic) {
-    el.classBinding = classResult
-  }
-}
-
-function genData (el: ASTElement): string {
-  let data = ''
-  if (el.staticClass) {
-    data += `staticClass:${el.staticClass},`
-  }
-  if (el.classBinding) {
-    data += `class:${el.classBinding},`
-  }
-  return data
-}
-
-function parseStaticClass (staticClass: ?string, options: CompilerOptions): StaticClassResult {
-  // "a b c" -> ["a", "b", "c"] => staticClass: ["a", "b", "c"]
-  // "a {{x}} c" -> ["a", x, "c"] => classBinding: '["a", x, "c"]'
-  let dynamic = false
-  let classResult = ''
-  if (staticClass) {
-    const classList = staticClass.trim().split(' ').map(name => {
-      const result = parseText(name, options.delimiters)
-      if (result) {
-        dynamic = true
-        return result.expression
-      }
-      return JSON.stringify(name)
-    })
-    if (classList.length) {
-      classResult = '[' + classList.join(',') + ']'
-    }
-  }
-  return { dynamic, classResult }
-}
-
-export default {
-  staticKeys: ['staticClass'],
-  transformNode,
-  genData
-}
diff --git a/1.Vue/src/platforms/weex/compiler/modules/index.js b/1.Vue/src/platforms/weex/compiler/modules/index.js
deleted file mode 100644
index ac17809..0000000
--- a/1.Vue/src/platforms/weex/compiler/modules/index.js
+++ /dev/null
@@ -1,13 +0,0 @@
-import klass from './class'
-import style from './style'
-import props from './props'
-import append from './append'
-import recycleList from './recycle-list/index'
-
-export default [
-  recycleList,
-  klass,
-  style,
-  props,
-  append
-]
diff --git a/1.Vue/src/platforms/weex/compiler/modules/props.js b/1.Vue/src/platforms/weex/compiler/modules/props.js
deleted file mode 100644
index f7e21fe..0000000
--- a/1.Vue/src/platforms/weex/compiler/modules/props.js
+++ /dev/null
@@ -1,37 +0,0 @@
-/* @flow */
-
-import { cached, camelize } from 'shared/util'
-
-const normalize = cached(camelize)
-
-function normalizeKeyName (str: string): string {
-  if (str.match(/^v\-/)) {
-    return str.replace(/(v-[a-z\-]+\:)([a-z\-]+)$/i, ($, directive, prop) => {
-      return directive + normalize(prop)
-    })
-  }
-  return normalize(str)
-}
-
-function transformNode (el: ASTElement) {
-  if (Array.isArray(el.attrsList)) {
-    el.attrsList.forEach(attr => {
-      if (attr.name && attr.name.match(/\-/)) {
-        const realName = normalizeKeyName(attr.name)
-        if (el.attrsMap) {
-          el.attrsMap[realName] = el.attrsMap[attr.name]
-          delete el.attrsMap[attr.name]
-        }
-        if (el.rawAttrsMap && el.rawAttrsMap[attr.name]) {
-          el.rawAttrsMap[realName] = el.rawAttrsMap[attr.name]
-          // $flow-disable-line
-          delete el.rawAttrsMap[attr.name]
-        }
-        attr.name = realName
-      }
-    })
-  }
-}
-export default {
-  transformNode
-}
diff --git a/1.Vue/src/platforms/weex/compiler/modules/recycle-list/component-root.js b/1.Vue/src/platforms/weex/compiler/modules/recycle-list/component-root.js
deleted file mode 100644
index 5138799..0000000
--- a/1.Vue/src/platforms/weex/compiler/modules/recycle-list/component-root.js
+++ /dev/null
@@ -1,13 +0,0 @@
-/* @flow */
-
-import { addAttr } from 'compiler/helpers'
-
-// mark component root nodes as
-export function postTransformComponentRoot (el: ASTElement) {
-  if (!el.parent) {
-    // component root
-    addAttr(el, '@isComponentRoot', 'true')
-    addAttr(el, '@templateId', '_uid')
-    addAttr(el, '@componentProps', '$props || {}')
-  }
-}
diff --git a/1.Vue/src/platforms/weex/compiler/modules/recycle-list/component.js b/1.Vue/src/platforms/weex/compiler/modules/recycle-list/component.js
deleted file mode 100644
index 36d7dfd..0000000
--- a/1.Vue/src/platforms/weex/compiler/modules/recycle-list/component.js
+++ /dev/null
@@ -1,16 +0,0 @@
-/* @flow */
-
-import { addAttr } from 'compiler/helpers'
-import { RECYCLE_LIST_MARKER } from 'weex/util/index'
-
-// mark components as inside recycle-list so that we know we need to invoke
-// their special @render function instead of render in create-component.js
-export function postTransformComponent (
-  el: ASTElement,
-  options: WeexCompilerOptions
-) {
-  // $flow-disable-line (we know isReservedTag is there)
-  if (!options.isReservedTag(el.tag) && el.tag !== 'cell-slot') {
-    addAttr(el, RECYCLE_LIST_MARKER, 'true')
-  }
-}
diff --git a/1.Vue/src/platforms/weex/compiler/modules/recycle-list/index.js b/1.Vue/src/platforms/weex/compiler/modules/recycle-list/index.js
deleted file mode 100644
index e75b174..0000000
--- a/1.Vue/src/platforms/weex/compiler/modules/recycle-list/index.js
+++ /dev/null
@@ -1,60 +0,0 @@
-/* @flow */
-
-import { preTransformRecycleList } from './recycle-list'
-import { postTransformComponent } from './component'
-import { postTransformComponentRoot } from './component-root'
-import { postTransformText } from './text'
-import { preTransformVBind } from './v-bind'
-import { preTransformVIf } from './v-if'
-import { preTransformVFor } from './v-for'
-import { postTransformVOn } from './v-on'
-import { preTransformVOnce } from './v-once'
-
-let currentRecycleList = null
-
-function shouldCompile (el: ASTElement, options: WeexCompilerOptions) {
-  return options.recyclable ||
-    (currentRecycleList && el !== currentRecycleList)
-}
-
-function preTransformNode (el: ASTElement, options: WeexCompilerOptions) {
-  if (el.tag === 'recycle-list') {
-    preTransformRecycleList(el, options)
-    currentRecycleList = el
-  }
-  if (shouldCompile(el, options)) {
-    preTransformVBind(el)
-    preTransformVIf(el, options) // also v-else-if and v-else
-    preTransformVFor(el, options)
-    preTransformVOnce(el)
-  }
-}
-
-function transformNode (el: ASTElement, options: WeexCompilerOptions) {
-  if (shouldCompile(el, options)) {
-    // do nothing yet
-  }
-}
-
-function postTransformNode (el: ASTElement, options: WeexCompilerOptions) {
-  if (shouldCompile(el, options)) {
-    // mark child component in parent template
-    postTransformComponent(el, options)
-    // mark root in child component template
-    postTransformComponentRoot(el)
-    // <text>: transform children text into value attr
-    if (el.tag === 'text') {
-      postTransformText(el)
-    }
-    postTransformVOn(el)
-  }
-  if (el === currentRecycleList) {
-    currentRecycleList = null
-  }
-}
-
-export default {
-  preTransformNode,
-  transformNode,
-  postTransformNode
-}
diff --git a/1.Vue/src/platforms/weex/compiler/modules/recycle-list/recycle-list.js b/1.Vue/src/platforms/weex/compiler/modules/recycle-list/recycle-list.js
deleted file mode 100644
index 7fb6516..0000000
--- a/1.Vue/src/platforms/weex/compiler/modules/recycle-list/recycle-list.js
+++ /dev/null
@@ -1,50 +0,0 @@
-/* @flow */
-
-import { parseFor } from 'compiler/parser/index'
-import { getAndRemoveAttr, addRawAttr } from 'compiler/helpers'
-
-/**
- * Map the following syntax to corresponding attrs:
- *
- * <recycle-list for="(item, i) in longList" switch="cellType">
- *   <cell-slot case="A"> ... </cell-slot>
- *   <cell-slot case="B"> ... </cell-slot>
- * </recycle-list>
- */
-
-export function preTransformRecycleList (
-  el: ASTElement,
-  options: WeexCompilerOptions
-) {
-  const exp = getAndRemoveAttr(el, 'for')
-  if (!exp) {
-    if (options.warn) {
-      options.warn(`Invalid <recycle-list> syntax: missing "for" expression.`)
-    }
-    return
-  }
-
-  const res = parseFor(exp)
-  if (!res) {
-    if (options.warn) {
-      options.warn(`Invalid <recycle-list> syntax: ${exp}.`)
-    }
-    return
-  }
-
-  addRawAttr(el, ':list-data', res.for)
-  addRawAttr(el, 'binding-expression', res.for)
-  addRawAttr(el, 'alias', res.alias)
-  if (res.iterator2) {
-    // (item, key, index) for object iteration
-    // is this even supported?
-    addRawAttr(el, 'index', res.iterator2)
-  } else if (res.iterator1) {
-    addRawAttr(el, 'index', res.iterator1)
-  }
-
-  const switchKey = getAndRemoveAttr(el, 'switch')
-  if (switchKey) {
-    addRawAttr(el, 'switch', switchKey)
-  }
-}
diff --git a/1.Vue/src/platforms/weex/compiler/modules/recycle-list/text.js b/1.Vue/src/platforms/weex/compiler/modules/recycle-list/text.js
deleted file mode 100644
index b3cbd06..0000000
--- a/1.Vue/src/platforms/weex/compiler/modules/recycle-list/text.js
+++ /dev/null
@@ -1,23 +0,0 @@
-/* @flow */
-
-import { addAttr } from 'compiler/helpers'
-
-function genText (node: ASTNode) {
-  const value = node.type === 3
-    ? node.text
-    : node.type === 2
-      ? node.tokens.length === 1
-        ? node.tokens[0]
-        : node.tokens
-      : ''
-  return JSON.stringify(value)
-}
-
-export function postTransformText (el: ASTElement) {
-  // weex <text> can only contain text, so the parser
-  // always generates a single child.
-  if (el.children.length) {
-    addAttr(el, 'value', genText(el.children[0]))
-    el.children = []
-  }
-}
diff --git a/1.Vue/src/platforms/weex/compiler/modules/recycle-list/v-bind.js b/1.Vue/src/platforms/weex/compiler/modules/recycle-list/v-bind.js
deleted file mode 100644
index 14f0f68..0000000
--- a/1.Vue/src/platforms/weex/compiler/modules/recycle-list/v-bind.js
+++ /dev/null
@@ -1,21 +0,0 @@
-/* @flow */
-
-import { camelize } from 'shared/util'
-import { generateBinding } from 'weex/util/parser'
-import { bindRE } from 'compiler/parser/index'
-import { getAndRemoveAttr, addRawAttr } from 'compiler/helpers'
-
-function parseAttrName (name: string): string {
-  return camelize(name.replace(bindRE, ''))
-}
-
-export function preTransformVBind (el: ASTElement) {
-  for (const attr in el.attrsMap) {
-    if (bindRE.test(attr)) {
-      const name: string = parseAttrName(attr)
-      const value = generateBinding(getAndRemoveAttr(el, attr))
-      delete el.attrsMap[attr]
-      addRawAttr(el, name, value)
-    }
-  }
-}
diff --git a/1.Vue/src/platforms/weex/compiler/modules/recycle-list/v-for.js b/1.Vue/src/platforms/weex/compiler/modules/recycle-list/v-for.js
deleted file mode 100644
index 9f09e4b..0000000
--- a/1.Vue/src/platforms/weex/compiler/modules/recycle-list/v-for.js
+++ /dev/null
@@ -1,33 +0,0 @@
-/* @flow */
-
-import { parseFor } from 'compiler/parser/index'
-import { getAndRemoveAttr, addRawAttr } from 'compiler/helpers'
-
-export function preTransformVFor (el: ASTElement, options: WeexCompilerOptions) {
-  const exp = getAndRemoveAttr(el, 'v-for')
-  if (!exp) {
-    return
-  }
-
-  const res = parseFor(exp)
-  if (!res) {
-    if (process.env.NODE_ENV !== 'production' && options.warn) {
-      options.warn(`Invalid v-for expression: ${exp}`)
-    }
-    return
-  }
-
-  const desc: Object = {
-    '@expression': res.for,
-    '@alias': res.alias
-  }
-  if (res.iterator2) {
-    desc['@key'] = res.iterator1
-    desc['@index'] = res.iterator2
-  } else {
-    desc['@index'] = res.iterator1
-  }
-
-  delete el.attrsMap['v-for']
-  addRawAttr(el, '[[repeat]]', desc)
-}
diff --git a/1.Vue/src/platforms/weex/compiler/modules/recycle-list/v-if.js b/1.Vue/src/platforms/weex/compiler/modules/recycle-list/v-if.js
deleted file mode 100644
index d82ba63..0000000
--- a/1.Vue/src/platforms/weex/compiler/modules/recycle-list/v-if.js
+++ /dev/null
@@ -1,63 +0,0 @@
-/* @flow */
-
-import { addIfCondition } from 'compiler/parser/index'
-import { getAndRemoveAttr, addRawAttr } from 'compiler/helpers'
-
-function hasConditionDirective (el: ASTElement): boolean {
-  for (const attr in el.attrsMap) {
-    if (/^v\-if|v\-else|v\-else\-if$/.test(attr)) {
-      return true
-    }
-  }
-  return false
-}
-
-function getPreviousConditions (el: ASTElement): Array<string> {
-  const conditions = []
-  if (el.parent && el.parent.children) {
-    for (let c = 0, n = el.parent.children.length; c < n; ++c) {
-      // $flow-disable-line
-      const ifConditions = el.parent.children[c].ifConditions
-      if (ifConditions) {
-        for (let i = 0, l = ifConditions.length; i < l; ++i) {
-          const condition = ifConditions[i]
-          if (condition && condition.exp) {
-            conditions.push(condition.exp)
-          }
-        }
-      }
-    }
-  }
-  return conditions
-}
-
-export function preTransformVIf (el: ASTElement, options: WeexCompilerOptions) {
-  if (hasConditionDirective(el)) {
-    let exp
-    const ifExp = getAndRemoveAttr(el, 'v-if', true /* remove from attrsMap */)
-    const elseifExp = getAndRemoveAttr(el, 'v-else-if', true)
-    // don't need the value, but remove it to avoid being generated as a
-    // custom directive
-    getAndRemoveAttr(el, 'v-else', true)
-    if (ifExp) {
-      exp = ifExp
-      addIfCondition(el, { exp: ifExp, block: el })
-    } else {
-      elseifExp && addIfCondition(el, { exp: elseifExp, block: el })
-      const prevConditions = getPreviousConditions(el)
-      if (prevConditions.length) {
-        const prevMatch = prevConditions.join(' || ')
-        exp = elseifExp
-          ? `!(${prevMatch}) && (${elseifExp})` // v-else-if
-          : `!(${prevMatch})` // v-else
-      } else if (process.env.NODE_ENV !== 'production' && options.warn) {
-        options.warn(
-          `v-${elseifExp ? ('else-if="' + elseifExp + '"') : 'else'} ` +
-          `used on element <${el.tag}> without corresponding v-if.`
-        )
-        return
-      }
-    }
-    addRawAttr(el, '[[match]]', exp)
-  }
-}
diff --git a/1.Vue/src/platforms/weex/compiler/modules/recycle-list/v-on.js b/1.Vue/src/platforms/weex/compiler/modules/recycle-list/v-on.js
deleted file mode 100644
index aed3ea7..0000000
--- a/1.Vue/src/platforms/weex/compiler/modules/recycle-list/v-on.js
+++ /dev/null
@@ -1,25 +0,0 @@
-/* @flow */
-
-const inlineStatementRE = /^\s*([A-Za-z_$0-9\['\."\]]+)*\s*\(\s*(([A-Za-z_$0-9\['\."\]]+)?(\s*,\s*([A-Za-z_$0-9\['\."\]]+))*)\s*\)$/
-
-function parseHandlerParams (handler: ASTElementHandler) {
-  const res = inlineStatementRE.exec(handler.value)
-  if (res && res[2]) {
-    handler.params = res[2].split(/\s*,\s*/)
-  }
-}
-
-export function postTransformVOn (el: ASTElement) {
-  const events: ASTElementHandlers | void = el.events
-  if (!events) {
-    return
-  }
-  for (const name in events) {
-    const handler: ASTElementHandler | Array<ASTElementHandler> = events[name]
-    if (Array.isArray(handler)) {
-      handler.map(fn => parseHandlerParams(fn))
-    } else {
-      parseHandlerParams(handler)
-    }
-  }
-}
diff --git a/1.Vue/src/platforms/weex/compiler/modules/recycle-list/v-once.js b/1.Vue/src/platforms/weex/compiler/modules/recycle-list/v-once.js
deleted file mode 100644
index 99380c7..0000000
--- a/1.Vue/src/platforms/weex/compiler/modules/recycle-list/v-once.js
+++ /dev/null
@@ -1,19 +0,0 @@
-/* @flow */
-
-import { getAndRemoveAttr, addRawAttr } from 'compiler/helpers'
-
-function containVOnce (el: ASTElement): boolean {
-  for (const attr in el.attrsMap) {
-    if (/^v\-once$/i.test(attr)) {
-      return true
-    }
-  }
-  return false
-}
-
-export function preTransformVOnce (el: ASTElement) {
-  if (containVOnce(el)) {
-    getAndRemoveAttr(el, 'v-once', true)
-    addRawAttr(el, '[[once]]', true)
-  }
-}
diff --git a/1.Vue/src/platforms/weex/compiler/modules/style.js b/1.Vue/src/platforms/weex/compiler/modules/style.js
deleted file mode 100644
index 9b0cd44..0000000
--- a/1.Vue/src/platforms/weex/compiler/modules/style.js
+++ /dev/null
@@ -1,87 +0,0 @@
-/* @flow */
-
-import { cached, camelize, isPlainObject } from 'shared/util'
-import { parseText } from 'compiler/parser/text-parser'
-import {
-  getAndRemoveAttr,
-  getBindingAttr,
-  baseWarn
-} from 'compiler/helpers'
-
-type StaticStyleResult = {
-  dynamic: boolean,
-  styleResult: string | Object | void
-};
-
-const normalize = cached(camelize)
-
-function transformNode (el: ASTElement, options: CompilerOptions) {
-  const warn = options.warn || baseWarn
-  const staticStyle = getAndRemoveAttr(el, 'style')
-  const { dynamic, styleResult } = parseStaticStyle(staticStyle, options)
-  if (process.env.NODE_ENV !== 'production' && dynamic) {
-    warn(
-      `style="${String(staticStyle)}": ` +
-      'Interpolation inside attributes has been deprecated. ' +
-      'Use v-bind or the colon shorthand instead.',
-      el.rawAttrsMap['style']
-    )
-  }
-  if (!dynamic && styleResult) {
-    // $flow-disable-line
-    el.staticStyle = styleResult
-  }
-  const styleBinding = getBindingAttr(el, 'style', false /* getStatic */)
-  if (styleBinding) {
-    el.styleBinding = styleBinding
-  } else if (dynamic) {
-    // $flow-disable-line
-    el.styleBinding = styleResult
-  }
-}
-
-function genData (el: ASTElement): string {
-  let data = ''
-  if (el.staticStyle) {
-    data += `staticStyle:${el.staticStyle},`
-  }
-  if (el.styleBinding) {
-    data += `style:${el.styleBinding},`
-  }
-  return data
-}
-
-function parseStaticStyle (staticStyle: ?string, options: CompilerOptions): StaticStyleResult {
-  // "width: 200px; height: 200px;" -> {width: 200, height: 200}
-  // "width: 200px; height: {{y}}" -> {width: 200, height: y}
-  let dynamic = false
-  let styleResult = ''
-  if (typeof staticStyle === 'string') {
-    const styleList = staticStyle.trim().split(';').map(style => {
-      const result = style.trim().split(':')
-      if (result.length !== 2) {
-        return
-      }
-      const key = normalize(result[0].trim())
-      const value = result[1].trim()
-      const dynamicValue = parseText(value, options.delimiters)
-      if (dynamicValue) {
-        dynamic = true
-        return key + ':' + dynamicValue.expression
-      }
-      return key + ':' + JSON.stringify(value)
-    }).filter(result => result)
-    if (styleList.length) {
-      styleResult = '{' + styleList.join(',') + '}'
-    }
-  } else if (isPlainObject(staticStyle)) {
-    styleResult = JSON.stringify(staticStyle) || ''
-  }
-  return { dynamic, styleResult }
-}
-
-export default {
-  staticKeys: ['staticStyle'],
-  transformNode,
-  genData
-}
diff --git a/1.Vue/src/platforms/weex/entry-compiler.js b/1.Vue/src/platforms/weex/entry-compiler.js
deleted file mode 100644
index b8f3f8f..0000000
--- a/1.Vue/src/platforms/weex/entry-compiler.js
+++ /dev/null
@@ -1,2 +0,0 @@
-export { compile } from 'weex/compiler/index'
-export { generateCodeFrame } from 'compiler/codeframe'
diff --git a/1.Vue/src/platforms/weex/entry-framework.js b/1.Vue/src/platforms/weex/entry-framework.js
deleted file mode 100644
index a23775d..0000000
--- a/1.Vue/src/platforms/weex/entry-framework.js
+++ /dev/null
@@ -1,187 +0,0 @@
-/* @flow */
-
-// this will be preserved during build
-// $flow-disable-line
-const VueFactory = require('./factory')
-
-const instanceOptions: { [key: string]: WeexInstanceOption } = {}
-
-/**
- * Create instance context.
- */
-export function createInstanceContext (
-  instanceId: string,
-  runtimeContext: WeexRuntimeContext,
-  data: Object = {}
-): WeexInstanceContext {
-  const weex: Weex = runtimeContext.weex
-  const instance: WeexInstanceOption = instanceOptions[instanceId] = {
-    instanceId,
-    config: weex.config,
-    document: weex.document,
-    data
-  }
-
-  // Each instance has a independent `Vue` module instance
-  const Vue = instance.Vue = createVueModuleInstance(instanceId, weex)
-
-  // DEPRECATED
-  const timerAPIs = getInstanceTimer(instanceId, weex.requireModule)
-
-  const instanceContext = Object.assign({ Vue }, timerAPIs)
-  Object.freeze(instanceContext)
-  return instanceContext
-}
-
-/**
- * Destroy an instance with id. It will make sure all memory of
- * this instance released and no more leaks.
- */
-export function destroyInstance (instanceId: string): void {
-  const instance = instanceOptions[instanceId]
-  if (instance && instance.app instanceof instance.Vue) {
-    try {
-      instance.app.$destroy()
-      instance.document.destroy()
-    } catch (e) {}
-    delete instance.document
-    delete instance.app
-  }
-  delete instanceOptions[instanceId]
-}
-
-/**
- * Refresh an instance with id and new top-level component data.
- * It will use `Vue.set` on all keys of the new data. So it's better
- * define all possible meaningful keys when instance created.
- */
-export function refreshInstance (
-  instanceId: string,
-  data: Object
-): Error | void {
-  const instance = instanceOptions[instanceId]
-  if (!instance || !(instance.app instanceof instance.Vue)) {
-    return new Error(`refreshInstance: instance ${instanceId} not found!`)
-  }
-  if (instance.Vue && instance.Vue.set) {
-    for (const key in data) {
-      instance.Vue.set(instance.app, key, data[key])
-    }
-  }
-  // Finally `refreshFinish` signal needed.
-  instance.document.taskCenter.send('dom', { action: 'refreshFinish' }, [])
-}
-
-/**
- * Create a fresh instance of Vue for each Weex instance.
- */
-function createVueModuleInstance (
-  instanceId: string,
-  weex: Weex
-): GlobalAPI {
-  const exports = {}
-  VueFactory(exports, weex.document)
-  const Vue = exports.Vue
-
-  const instance = instanceOptions[instanceId]
-
-  // patch reserved tag detection to account for dynamically registered
-  // components
-  const weexRegex = /^weex:/i
-  const isReservedTag = Vue.config.isReservedTag || (() => false)
-  const isRuntimeComponent = Vue.config.isRuntimeComponent || (() => false)
-  Vue.config.isReservedTag = name => {
-    return (!isRuntimeComponent(name) && weex.supports(`@component/${name}`)) ||
-      isReservedTag(name) ||
-      weexRegex.test(name)
-  }
-  Vue.config.parsePlatformTagName = name => name.replace(weexRegex, '')
-
-  // expose weex-specific info
-  Vue.prototype.$instanceId = instanceId
-  Vue.prototype.$document = instance.document
-
-  // expose weex native module getter on subVue prototype so that
-  // vdom runtime modules can access native modules via vnode.context
-  Vue.prototype.$requireWeexModule = weex.requireModule
-
-  // Hack `Vue` behavior to handle instance information and data
-  // before root component created.
-  Vue.mixin({
-    beforeCreate () {
-      const options = this.$options
-      // root component (vm)
-      if (options.el) {
-        // set external data of instance
-        const dataOption = options.data
-        const internalData = (typeof dataOption === 'function' ? dataOption() : dataOption) || {}
-        options.data = Object.assign(internalData, instance.data)
-        // record instance by id
-        instance.app = this
-      }
-    },
-    mounted () {
-      const options = this.$options
-      // root component (vm)
-      if (options.el && weex.document && instance.app === this) {
-        try {
-          // Send "createFinish" signal to native.
-          weex.document.taskCenter.send('dom', { action: 'createFinish' }, [])
-        } catch (e) {}
-      }
-    }
-  })
-
-  /**
-   * @deprecated Just instance variable `weex.config`
-   * Get instance config.
-   * @return {object}
-   */
-  Vue.prototype.$getConfig = function () {
-    if (instance.app instanceof Vue) {
-      return instance.config
-    }
-  }
-
-  return Vue
-}
-
-/**
- * DEPRECATED
- * Generate HTML5 Timer APIs. An important point is that the callback
- * will be converted into callback id when sent to native. So the
- * framework can make sure no side effect of the callback happened after
- * an instance destroyed.
- */
-function getInstanceTimer (
-  instanceId: string,
-  moduleGetter: Function
-): Object {
-  const instance = instanceOptions[instanceId]
-  const timer = moduleGetter('timer')
-  const timerAPIs = {
-    setTimeout: (...args) => {
-      const handler = function () {
-        args[0](...args.slice(2))
-      }
-
-      timer.setTimeout(handler, args[1])
-      return instance.document.taskCenter.callbackManager.lastCallbackId.toString()
-    },
-    setInterval: (...args) => {
-      const handler = function () {
-        args[0](...args.slice(2))
-      }
-
-      timer.setInterval(handler, args[1])
-      return instance.document.taskCenter.callbackManager.lastCallbackId.toString()
-    },
-    clearTimeout: (n) => {
-      timer.clearTimeout(n)
-    },
-    clearInterval: (n) => {
-      timer.clearInterval(n)
-    }
-  }
-  return timerAPIs
-}
diff --git a/1.Vue/src/platforms/weex/entry-runtime-factory.js b/1.Vue/src/platforms/weex/entry-runtime-factory.js
deleted file mode 100644
index 166ddf2..0000000
--- a/1.Vue/src/platforms/weex/entry-runtime-factory.js
+++ /dev/null
@@ -1,6 +0,0 @@
-// this entry is built and wrapped with a factory function
-// used to generate a fresh copy of Vue for every Weex instance.
-
-import Vue from './runtime/index'
-
-exports.Vue = Vue
diff --git a/1.Vue/src/platforms/weex/runtime/components/index.js b/1.Vue/src/platforms/weex/runtime/components/index.js
deleted file mode 100644
index 449db1a..0000000
--- a/1.Vue/src/platforms/weex/runtime/components/index.js
+++ /dev/null
@@ -1,9 +0,0 @@
-import Richtext from './richtext'
-import Transition from './transition'
-import TransitionGroup from './transition-group'
-
-export default {
-  Richtext,
-  Transition,
-  TransitionGroup
-}
diff --git a/1.Vue/src/platforms/weex/runtime/components/richtext.js b/1.Vue/src/platforms/weex/runtime/components/richtext.js
deleted file mode 100644
index a9164c7..0000000
--- a/1.Vue/src/platforms/weex/runtime/components/richtext.js
+++ /dev/null
@@ -1,82 +0,0 @@
-/* @flow */
-
-function getVNodeType (vnode: VNode): string {
-  if (!vnode.tag) {
-    return ''
-  }
-  return vnode.tag.replace(/vue\-component\-(\d+\-)?/, '')
-}
-
-function isSimpleSpan (vnode: VNode): boolean {
-  return vnode.children &&
-    vnode.children.length === 1 &&
-    !vnode.children[0].tag
-}
-
-function parseStyle (vnode: VNode): Object | void {
-  if (!vnode || !vnode.data) {
-    return
-  }
-  const { staticStyle, staticClass } = vnode.data
-  if (vnode.data.style || vnode.data.class || staticStyle || staticClass) {
-    const styles = Object.assign({}, staticStyle, vnode.data.style)
-    const cssMap = vnode.context.$options.style || {}
-    const classList = [].concat(staticClass, vnode.data.class)
-    classList.forEach(name => {
-      if (name && cssMap[name]) {
-        Object.assign(styles, cssMap[name])
-      }
-    })
-    return styles
-  }
-}
-
-function convertVNodeChildren (children: Array<VNode>): Array<VNode> | void {
-  if (!children.length) {
-    return
-  }
-
-  return children.map(vnode => {
-    const type: string = getVNodeType(vnode)
-    const props: Object = { type }
-
-    // convert raw text node
-    if (!type) {
-      props.type = 'span'
-      props.attr = {
-        value: (vnode.text || '').trim()
-      }
-    } else {
-      props.style = parseStyle(vnode)
-      if (vnode.data) {
-        props.attr = vnode.data.attrs
-        if (vnode.data.on) {
-          props.events = vnode.data.on
-        }
-      }
-      if (type === 'span' && isSimpleSpan(vnode)) {
-        props.attr = props.attr || {}
-        props.attr.value = vnode.children[0].text.trim()
-        return props
-      }
-    }
-
-    if (vnode.children && vnode.children.length) {
-      props.children = convertVNodeChildren(vnode.children)
-    }
-
-    return props
-  })
-}
-
-export default {
-  name: 'richtext',
-  render (h: Function) {
-    return h('weex:richtext', {
-      on: this._events,
-      attrs: {
-        value: convertVNodeChildren(this.$options._renderChildren || [])
-      }
-    })
-  }
-}
diff --git a/1.Vue/src/platforms/weex/runtime/components/transition-group.js b/1.Vue/src/platforms/weex/runtime/components/transition-group.js
deleted file mode 100644
index 4a65965..0000000
--- a/1.Vue/src/platforms/weex/runtime/components/transition-group.js
+++ /dev/null
@@ -1,148 +0,0 @@
-import { warn, extend } from 'core/util/index'
-import { transitionProps, extractTransitionData } from './transition'
-
-const props = extend({
-  tag: String,
-  moveClass: String
-}, transitionProps)
-
-delete props.mode
-
-export default {
-  props,
-
-  created () {
-    const dom = this.$requireWeexModule('dom')
-    this.getPosition = el => new Promise((resolve, reject) => {
-      dom.getComponentRect(el.ref, res => {
-        if (!res.result) {
-          reject(new Error(`failed to get rect for element: ${el.tag}`))
-        } else {
-          resolve(res.size)
-        }
-      })
-    })
-
-    const animation = this.$requireWeexModule('animation')
-    this.animate = (el, options) => new Promise(resolve => {
-      animation.transition(el.ref, options, resolve)
-    })
-  },
-
-  render (h) {
-    const tag = this.tag || this.$vnode.data.tag || 'span'
-    const map = Object.create(null)
-    const prevChildren = this.prevChildren = this.children
-    const rawChildren = this.$slots.default || []
-    const children = this.children = []
-    const transitionData = extractTransitionData(this)
-
-    for (let i = 0; i < rawChildren.length; i++) {
-      const c = rawChildren[i]
-      if (c.tag) {
-        if (c.key != null && String(c.key).indexOf('__vlist') !== 0) {
-          children.push(c)
-          map[c.key] = c
-          ;(c.data || (c.data = {})).transition = transitionData
-        } else if (process.env.NODE_ENV !== 'production') {
-          const opts = c.componentOptions
-          const name = opts
-            ? (opts.Ctor.options.name || opts.tag)
-            : c.tag
-          warn(`<transition-group> children must be keyed: <${name}>`)
-        }
-      }
-    }
-
-    if (prevChildren) {
-      const kept = []
-      const removed = []
-      prevChildren.forEach(c => {
-        c.data.transition = transitionData
-
-        // TODO: record before patch positions
-
-        if (map[c.key]) {
-          kept.push(c)
-        } else {
-          removed.push(c)
-        }
-      })
-      this.kept = h(tag, null, kept)
-      this.removed = removed
-    }
-
-    return h(tag, null, children)
-  },
-
-  beforeUpdate () {
-    // force removing pass
-    this.__patch__(
-      this._vnode,
-      this.kept,
-      false, // hydrating
-      true // removeOnly (!important, avoids unnecessary moves)
-    )
-    this._vnode = this.kept
-  },
-
-  updated () {
-    const children = this.prevChildren
-    const moveClass = this.moveClass || ((this.name || 'v') + '-move')
-    const moveData = children.length && this.getMoveData(children[0].context, moveClass)
-    if (!moveData) {
-      return
-    }
-
-    // TODO: finish implementing move animations once
-    // we have access to sync getComponentRect()
-
-    // children.forEach(callPendingCbs)
-
-    // Promise.all(children.map(c => {
-    //   const oldPos = c.data.pos
-    //   const newPos = c.data.newPos
-    //   const dx = oldPos.left - newPos.left
-    //   const dy = oldPos.top - newPos.top
-    //   if (dx || dy) {
-    //     c.data.moved = true
-    //     return this.animate(c.elm, {
-    //       styles: {
-    //         transform: `translate(${dx}px,${dy}px)`
-    //       }
-    //     })
-    //   }
-    // })).then(() => {
-    //   children.forEach(c => {
-    //     if (c.data.moved) {
-    //       this.animate(c.elm, {
-    //         styles: {
-    //           transform: ''
-    //         },
-    //         duration: moveData.duration || 0,
-    //         delay: moveData.delay || 0,
-    //         timingFunction: moveData.timingFunction || 'linear'
-    //       })
-    //     }
-    //   })
-    // })
-  },
-
-  methods: {
-    getMoveData (context, moveClass) {
-      const stylesheet = context.$options.style || {}
-      return stylesheet['@TRANSITION'] && stylesheet['@TRANSITION'][moveClass]
-    }
-  }
-}
-
-// function callPendingCbs (c) {
-//   /* istanbul ignore if */
-//   if (c.elm._moveCb) {
-//     c.elm._moveCb()
-//   }
-//   /* istanbul ignore if */
-//   if (c.elm._enterCb) {
-//     c.elm._enterCb()
-//   }
-// }
diff --git a/1.Vue/src/platforms/weex/runtime/components/transition.js b/1.Vue/src/platforms/weex/runtime/components/transition.js
deleted file mode 100644
index 20ba632..0000000
--- a/1.Vue/src/platforms/weex/runtime/components/transition.js
+++ /dev/null
@@ -1,9 +0,0 @@
-// reuse same transition component logic from web
-export {
-  transitionProps,
-  extractTransitionData
-} from 'web/runtime/components/transition'
-
-import Transition from 'web/runtime/components/transition'
-
-export default Transition
diff --git a/1.Vue/src/platforms/weex/runtime/directives/index.js b/1.Vue/src/platforms/weex/runtime/directives/index.js
deleted file mode 100644
index efba7fa..0000000
--- a/1.Vue/src/platforms/weex/runtime/directives/index.js
+++ /dev/null
@@ -1,2 +0,0 @@
-export default {
-}
diff --git a/1.Vue/src/platforms/weex/runtime/index.js b/1.Vue/src/platforms/weex/runtime/index.js
deleted file mode 100644
index b8e0930..0000000
--- a/1.Vue/src/platforms/weex/runtime/index.js
+++ /dev/null
@@ -1,42 +0,0 @@
-/* @flow */
-
-import Vue from 'core/index'
-import { patch } from 'weex/runtime/patch'
-import { mountComponent } from 'core/instance/lifecycle'
-import platformDirectives from 'weex/runtime/directives/index'
-import platformComponents from 'weex/runtime/components/index'
-
-import {
-  query,
-  mustUseProp,
-  isReservedTag,
-  isRuntimeComponent,
-  isUnknownElement
-} from 'weex/util/element'
-
-// install platform specific utils
-Vue.config.mustUseProp = mustUseProp
-Vue.config.isReservedTag = isReservedTag
-Vue.config.isRuntimeComponent = isRuntimeComponent
-Vue.config.isUnknownElement = isUnknownElement
-
-// install platform runtime directives and components
-Vue.options.directives = platformDirectives
-Vue.options.components = platformComponents
-
-// install platform patch function
-Vue.prototype.__patch__ = patch
-
-// wrap mount
-Vue.prototype.$mount = function (
-  el?: any,
-  hydrating?: boolean
-): Component {
-  return mountComponent(
-    this,
-    el && query(el, this.$document),
-    hydrating
-  )
-}
-
-export default Vue
diff --git a/1.Vue/src/platforms/weex/runtime/modules/attrs.js b/1.Vue/src/platforms/weex/runtime/modules/attrs.js
deleted file mode 100644
index 1b6185c..0000000
--- a/1.Vue/src/platforms/weex/runtime/modules/attrs.js
+++ /dev/null
@@ -1,44 +0,0 @@
-/* @flow */
-
-import { extend } from 'shared/util'
-
-function updateAttrs (oldVnode: VNodeWithData, vnode: VNodeWithData) {
-  if (!oldVnode.data.attrs && !vnode.data.attrs) {
-    return
-  }
-  let key, cur, old
-  const elm = vnode.elm
-  const oldAttrs = oldVnode.data.attrs || {}
-  let attrs = vnode.data.attrs || {}
-  // clone observed objects, as the user probably wants to mutate it
-  if (attrs.__ob__) {
-    attrs = vnode.data.attrs = extend({}, attrs)
-  }
-
-  const supportBatchUpdate = typeof elm.setAttrs === 'function'
-  const batchedAttrs = {}
-  for (key in attrs) {
-    cur = attrs[key]
-    old = oldAttrs[key]
-    if (old !== cur) {
-      supportBatchUpdate
-        ? (batchedAttrs[key] = cur)
-        : elm.setAttr(key, cur)
-    }
-  }
-  for (key in oldAttrs) {
-    if (attrs[key] == null) {
-      supportBatchUpdate
-        ? (batchedAttrs[key] = undefined)
-        : elm.setAttr(key)
-    }
-  }
-  if (supportBatchUpdate) {
-    elm.setAttrs(batchedAttrs)
-  }
-}
-
-export default {
-  create: updateAttrs,
-  update: updateAttrs
-}
diff --git a/1.Vue/src/platforms/weex/runtime/modules/class.js b/1.Vue/src/platforms/weex/runtime/modules/class.js
deleted file mode 100644
index 0a07bb3..0000000
--- a/1.Vue/src/platforms/weex/runtime/modules/class.js
+++ /dev/null
@@ -1,76 +0,0 @@
-/* @flow */
-
-import { extend, isObject } from 'shared/util'
-
-function updateClass (oldVnode: VNodeWithData, vnode: VNodeWithData) {
-  const el = vnode.elm
-  const ctx = vnode.context
-
-  const data: VNodeData = vnode.data
-  const oldData: VNodeData = oldVnode.data
-  if (!data.staticClass &&
-    !data.class &&
-    (!oldData || (!oldData.staticClass && !oldData.class))
-  ) {
-    return
-  }
-
-  const oldClassList = makeClassList(oldData)
-  const classList = makeClassList(data)
-
-  if (typeof el.setClassList === 'function') {
-    el.setClassList(classList)
-  } else {
-    const style = getStyle(oldClassList, classList, ctx)
-    if (typeof el.setStyles === 'function') {
-      el.setStyles(style)
-    } else {
-      for (const key in style) {
-        el.setStyle(key, style[key])
-      }
-    }
-  }
-}
-
-function makeClassList (data: VNodeData): Array<string> {
-  const classList = []
-  // unlike web, weex vnode staticClass is an Array
-  const staticClass: any = data.staticClass
-  const dataClass = data.class
-  if (staticClass) {
-    classList.push.apply(classList, staticClass)
-  }
-  if (Array.isArray(dataClass)) {
-    classList.push.apply(classList, dataClass)
-  } else if (isObject(dataClass)) {
-    classList.push.apply(classList, Object.keys(dataClass).filter(className => dataClass[className]))
-  } else if (typeof dataClass === 'string') {
-    classList.push.apply(classList, dataClass.trim().split(/\s+/))
-  }
-  return classList
-}
-
-function getStyle (oldClassList: Array<string>, classList: Array<string>, ctx: Component): Object {
-  // style is a weex-only injected object
-  // compiled from <style> tags in weex files
-  const stylesheet: any = ctx.$options.style || {}
-  const result = {}
-  classList.forEach(name => {
-    const style = stylesheet[name]
-    extend(result, style)
-  })
-  oldClassList.forEach(name => {
-    const style = stylesheet[name]
-    for (const key in style) {
-      if (!result.hasOwnProperty(key)) {
-        result[key] = ''
-      }
-    }
-  })
-  return result
-}
-
-export default {
-  create: updateClass,
-  update: updateClass
-}
diff --git a/1.Vue/src/platforms/weex/runtime/modules/events.js b/1.Vue/src/platforms/weex/runtime/modules/events.js
deleted file mode 100644
index c347194..0000000
--- a/1.Vue/src/platforms/weex/runtime/modules/events.js
+++ /dev/null
@@ -1,54 +0,0 @@
-/* @flow */
-
-import { updateListeners } from 'core/vdom/helpers/update-listeners'
-
-let target: any
-
-function createOnceHandler (event, handler, capture) {
-  const _target = target // save current target element in closure
-  return function onceHandler () {
-    const res = handler.apply(null, arguments)
-    if (res !== null) {
-      remove(event, onceHandler, capture, _target)
-    }
-  }
-}
-
-function add (
-  event: string,
-  handler: Function,
-  capture: boolean,
-  passive?: boolean,
-  params?: Array<any>
-) {
-  if (capture) {
-    console.log('Weex do not support event in bubble phase.')
-    return
-  }
-  target.addEvent(event, handler, params)
-}
-
-function remove (
-  event: string,
-  handler: any,
-  capture: any,
-  _target?: any
-) {
-  (_target || target).removeEvent(event)
-}
-
-function updateDOMListeners (oldVnode: VNodeWithData, vnode: VNodeWithData) {
-  if (!oldVnode.data.on && !vnode.data.on) {
-    return
-  }
-  const on = vnode.data.on || {}
-  const oldOn = oldVnode.data.on || {}
-  target = vnode.elm
-  updateListeners(on, oldOn, add, remove, createOnceHandler, vnode.context)
-  target = undefined
-}
-
-export default {
-  create: updateDOMListeners,
-  update: updateDOMListeners
-}
diff --git a/1.Vue/src/platforms/weex/runtime/modules/index.js b/1.Vue/src/platforms/weex/runtime/modules/index.js
deleted file mode 100644
index dd38448..0000000
--- a/1.Vue/src/platforms/weex/runtime/modules/index.js
+++ /dev/null
@@ -1,13 +0,0 @@
-import attrs from './attrs'
-import klass from './class'
-import events from './events'
-import style from './style'
-import transition from './transition'
-
-export default [
-  attrs,
-  klass,
-  events,
-  style,
-  transition
-]
diff --git a/1.Vue/src/platforms/weex/runtime/modules/style.js b/1.Vue/src/platforms/weex/runtime/modules/style.js
deleted file mode 100644
index 0ec217b..0000000
--- a/1.Vue/src/platforms/weex/runtime/modules/style.js
+++ /dev/null
@@ -1,84 +0,0 @@
-/* @flow */
-
-import { extend, cached, camelize } from 'shared/util'
-
-const normalize = cached(camelize)
-
-function createStyle (oldVnode: VNodeWithData, vnode: VNodeWithData) {
-  if (!vnode.data.staticStyle) {
-    updateStyle(oldVnode, vnode)
-    return
-  }
-  const elm = vnode.elm
-  const staticStyle = vnode.data.staticStyle
-  const supportBatchUpdate = typeof elm.setStyles === 'function'
-  const batchedStyles = {}
-  for (const name in staticStyle) {
-    if (staticStyle[name]) {
-      supportBatchUpdate
-        ? (batchedStyles[normalize(name)] = staticStyle[name])
-        : elm.setStyle(normalize(name), staticStyle[name])
-    }
-  }
-  if (supportBatchUpdate) {
-    elm.setStyles(batchedStyles)
-  }
-  updateStyle(oldVnode, vnode)
-}
-
-function updateStyle (oldVnode: VNodeWithData, vnode: VNodeWithData) {
-  if (!oldVnode.data.style && !vnode.data.style) {
-    return
-  }
-  let cur, name
-  const elm = vnode.elm
-  const oldStyle: any = oldVnode.data.style || {}
-  let style: any = vnode.data.style || {}
-
-  const needClone = style.__ob__
-
-  // handle array syntax
-  if (Array.isArray(style)) {
-    style = vnode.data.style = toObject(style)
-  }
-
-  // clone the style for future updates,
-  // in case the user mutates the style object in-place.
-  if (needClone) {
-    style = vnode.data.style = extend({}, style)
-  }
-
-  const supportBatchUpdate = typeof elm.setStyles === 'function'
-  const batchedStyles = {}
-  for (name in oldStyle) {
-    if (!style[name]) {
-      supportBatchUpdate
-        ? (batchedStyles[normalize(name)] = '')
-        : elm.setStyle(normalize(name), '')
-    }
-  }
-  for (name in style) {
-    cur = style[name]
-    supportBatchUpdate
-      ? (batchedStyles[normalize(name)] = cur)
-      : elm.setStyle(normalize(name), cur)
-  }
-  if (supportBatchUpdate) {
-    elm.setStyles(batchedStyles)
-  }
-}
-
-function toObject (arr) {
-  const res = {}
-  for (let i = 0; i < arr.length; i++) {
-    if (arr[i]) {
-      extend(res, arr[i])
-    }
-  }
-  return res
-}
-
-export default {
-  create: createStyle,
-  update: updateStyle
-}
diff --git a/1.Vue/src/platforms/weex/runtime/modules/transition.js b/1.Vue/src/platforms/weex/runtime/modules/transition.js
deleted file mode 100644
index cf87281..0000000
--- a/1.Vue/src/platforms/weex/runtime/modules/transition.js
+++ /dev/null
@@ -1,270 +0,0 @@
-import { warn } from 'core/util/debug'
-import { extend, once, noop } from 'shared/util'
-import { activeInstance } from 'core/instance/lifecycle'
-import { resolveTransition } from 'web/runtime/transition-util'
-
-export default {
-  create: enter,
-  activate: enter,
-  remove: leave
-}
-
-function enter (_, vnode) {
-  const el = vnode.elm
-
-  // call leave callback now
-  if (el._leaveCb) {
-    el._leaveCb.cancelled = true
-    el._leaveCb()
-  }
-
-  const data = resolveTransition(vnode.data.transition)
-  if (!data) {
-    return
-  }
-
-  /* istanbul ignore if */
-  if (el._enterCb) {
-    return
-  }
-
-  const {
-    enterClass,
-    enterToClass,
-    enterActiveClass,
-    appearClass,
-    appearToClass,
-    appearActiveClass,
-    beforeEnter,
-    enter,
-    afterEnter,
-    enterCancelled,
-    beforeAppear,
-    appear,
-    afterAppear,
-    appearCancelled
-  } = data
-
-  let context = activeInstance
-  let transitionNode = activeInstance.$vnode
-  while (transitionNode && transitionNode.parent) {
-    transitionNode = transitionNode.parent
-    context = transitionNode.context
-  }
-
-  const isAppear = !context._isMounted || !vnode.isRootInsert
-
-  if (isAppear && !appear && appear !== '') {
-    return
-  }
-
-  const startClass = isAppear ? appearClass : enterClass
-  const toClass = isAppear ? appearToClass : enterToClass
-  const activeClass = isAppear ? appearActiveClass : enterActiveClass
-  const beforeEnterHook = isAppear ? (beforeAppear || beforeEnter) : beforeEnter
-  const enterHook = isAppear ? (typeof appear === 'function' ? appear : enter) : enter
-  const afterEnterHook = isAppear ? (afterAppear || afterEnter) : afterEnter
-  const enterCancelledHook = isAppear ? (appearCancelled || enterCancelled) : enterCancelled
-
-  const userWantsControl =
-    enterHook &&
-    // enterHook may be a bound method which exposes
-    // the length of original fn as _length
-    (enterHook._length || enterHook.length) > 1
-
-  const stylesheet = vnode.context.$options.style || {}
-  const startState = stylesheet[startClass]
-  const transitionProperties = (stylesheet['@TRANSITION'] && stylesheet['@TRANSITION'][activeClass]) || {}
-  const endState = getEnterTargetState(el, stylesheet, startClass, toClass, activeClass)
-  const needAnimation = Object.keys(endState).length > 0
-
-  const cb = el._enterCb = once(() => {
-    if (cb.cancelled) {
-      enterCancelledHook && enterCancelledHook(el)
-    } else {
-      afterEnterHook && afterEnterHook(el)
-    }
-    el._enterCb = null
-  })
-
-  // We need to wait until the native element has been inserted, but currently
-  // there's no API to do that. So we have to wait "one frame" - not entirely
-  // sure if this is guaranteed to be enough (e.g. on slow devices?)
-  setTimeout(() => {
-    const parent = el.parentNode
-    const pendingNode = parent && parent._pending && parent._pending[vnode.key]
-    if (pendingNode &&
-      pendingNode.context === vnode.context &&
-      pendingNode.tag === vnode.tag &&
-      pendingNode.elm._leaveCb
-    ) {
-      pendingNode.elm._leaveCb()
-    }
-    enterHook && enterHook(el, cb)
-
-    if (needAnimation) {
-      const animation = vnode.context.$requireWeexModule('animation')
-      animation.transition(el.ref, {
-        styles: endState,
-        duration: transitionProperties.duration || 0,
-        delay: transitionProperties.delay || 0,
-        timingFunction: transitionProperties.timingFunction || 'linear'
-      }, userWantsControl ? noop : cb)
-    } else if (!userWantsControl) {
-      cb()
-    }
-  }, 16)
-
-  // start enter transition
-  beforeEnterHook && beforeEnterHook(el)
-
-  if (startState) {
-    if (typeof el.setStyles === 'function') {
-      el.setStyles(startState)
-    } else {
-      for (const key in startState) {
-        el.setStyle(key, startState[key])
-      }
-    }
-  }
-
-  if (!needAnimation && !userWantsControl) {
-    cb()
-  }
-}
-
-function leave (vnode, rm) {
-  const el = vnode.elm
-
-  // call enter callback now
-  if (el._enterCb) {
-    el._enterCb.cancelled = true
-    el._enterCb()
-  }
-
-  const data = resolveTransition(vnode.data.transition)
-  if (!data) {
-    return rm()
-  }
-
-  if (el._leaveCb) {
-    return
-  }
-
-  const {
-    leaveClass,
-    leaveToClass,
-    leaveActiveClass,
-    beforeLeave,
-    leave,
-    afterLeave,
-    leaveCancelled,
-    delayLeave
-  } = data
-
-  const userWantsControl =
-    leave &&
-    // leave hook may be a bound method which exposes
-    // the length of original fn as _length
-    (leave._length || leave.length) > 1
-
-  const stylesheet = vnode.context.$options.style || {}
-  const startState = stylesheet[leaveClass]
-  const endState = stylesheet[leaveToClass] || stylesheet[leaveActiveClass]
-  const transitionProperties = (stylesheet['@TRANSITION'] && stylesheet['@TRANSITION'][leaveActiveClass]) || {}
-
-  const cb = el._leaveCb = once(() => {
-    if (el.parentNode && el.parentNode._pending) {
-      el.parentNode._pending[vnode.key] = null
-    }
-    if (cb.cancelled) {
-      leaveCancelled && leaveCancelled(el)
-    } else {
-      rm()
-      afterLeave && afterLeave(el)
-    }
-    el._leaveCb = null
-  })
-
-  if (delayLeave) {
-    delayLeave(performLeave)
-  } else {
-    performLeave()
-  }
-
-  function performLeave () {
-    const animation = vnode.context.$requireWeexModule('animation')
-    // the delayed leave may have already been cancelled
-    if (cb.cancelled) {
-      return
-    }
-    // record leaving element
-    if (!vnode.data.show) {
-      (el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode
-    }
-    beforeLeave && beforeLeave(el)
-
-    if (startState) {
-      animation.transition(el.ref, {
-        styles: startState
-      }, next)
-    } else {
-      next()
-    }
-
-    function next () {
-      animation.transition(el.ref, {
-        styles: endState,
-        duration: transitionProperties.duration || 0,
-        delay: transitionProperties.delay || 0,
-        timingFunction: transitionProperties.timingFunction || 'linear'
-      }, userWantsControl ? noop : cb)
-    }
-
-    leave && leave(el, cb)
-    if (!endState && !userWantsControl) {
-      cb()
-    }
-  }
-}
-
-// determine the target animation style for an entering transition.
-function getEnterTargetState (el, stylesheet, startClass, endClass, activeClass) {
-  const targetState = {}
-  const startState = stylesheet[startClass]
-  const endState = stylesheet[endClass]
-  const activeState = stylesheet[activeClass]
-  // 1. fallback to element's default styling
-  if (startState) {
-    for (const key in startState) {
-      targetState[key] = el.style[key]
-      if (
-        process.env.NODE_ENV !== 'production' &&
-        targetState[key] == null &&
-        (!activeState || activeState[key] == null) &&
-        (!endState || endState[key] == null)
-      ) {
-        warn(
-          `transition property "${key}" is declared in enter starting class (.${startClass}), ` +
-          `but not declared anywhere in enter ending class (.${endClass}), ` +
-          `enter active cass (.${activeClass}) or the element's default styling. ` +
-          `Note in Weex, CSS properties need explicit values to be transitionable.`
-        )
-      }
-    }
-  }
-  // 2. if state is mixed in active state, extract them while excluding
-  //    transition properties
-  if (activeState) {
-    for (const key in activeState) {
-      if (key.indexOf('transition') !== 0) {
-        targetState[key] = activeState[key]
-      }
-    }
-  }
-  // 3. explicit endState has highest priority
-  if (endState) {
-    extend(targetState, endState)
-  }
-  return targetState
-}
diff --git a/1.Vue/src/platforms/weex/runtime/node-ops.js b/1.Vue/src/platforms/weex/runtime/node-ops.js
deleted file mode 100644
index 0438ec5..0000000
--- a/1.Vue/src/platforms/weex/runtime/node-ops.js
+++ /dev/null
@@ -1,91 +0,0 @@
-/* @flow */
-declare var document: WeexDocument;
-
-import TextNode from 'weex/runtime/text-node'
-
-export const namespaceMap = {}
-
-export function createElement (tagName: string): WeexElement {
-  return document.createElement(tagName)
-}
-
-export function createElementNS (namespace: string, tagName: string): WeexElement {
-  return document.createElement(namespace + ':' + tagName)
-}
-
-export function createTextNode (text: string) {
-  return new TextNode(text)
-}
-
-export function createComment (text: string) {
-  return document.createComment(text)
-}
-
-export function insertBefore (
-  node: WeexElement,
-  target: WeexElement,
-  before: WeexElement
-) {
-  if (target.nodeType === 3) {
-    if (node.type === 'text') {
-      node.setAttr('value', target.text)
-      target.parentNode = node
-    } else {
-      const text = createElement('text')
-      text.setAttr('value', target.text)
-      node.insertBefore(text, before)
-    }
-    return
-  }
-  node.insertBefore(target, before)
-}
-
-export function removeChild (node: WeexElement, child: WeexElement) {
-  if (child.nodeType === 3) {
-    node.setAttr('value', '')
-    return
-  }
-  node.removeChild(child)
-}
-
-export function appendChild (node: WeexElement, child: WeexElement) {
-  if (child.nodeType === 3) {
-    if (node.type === 'text') {
-      node.setAttr('value', child.text)
-      child.parentNode = node
-    } else {
-      const text = createElement('text')
-      text.setAttr('value', child.text)
-      node.appendChild(text)
-    }
-    return
-  }
-
-  node.appendChild(child)
-}
-
-export function parentNode (node: WeexElement): WeexElement | void {
-  return node.parentNode
-}
-
-export function nextSibling (node: WeexElement): WeexElement | void {
-  return node.nextSibling
-}
-
-export function tagName (node: WeexElement): string {
-  return node.type
-}
-
-export function setTextContent (node: WeexElement, text: string) {
-  if (node.parentNode) {
-    node.parentNode.setAttr('value', text)
-  }
-}
-
-export function setAttribute (node: WeexElement, key: string, val: any) {
-  node.setAttr(key, val)
-}
-
-export function setStyleScope (node: WeexElement, scopeId: string) {
-  node.setAttr('@styleScope', scopeId)
-}
diff --git a/1.Vue/src/platforms/weex/runtime/patch.js b/1.Vue/src/platforms/weex/runtime/patch.js
deleted file mode 100644
index 5e70d14..0000000
--- a/1.Vue/src/platforms/weex/runtime/patch.js
+++ /dev/null
@@ -1,16 +0,0 @@
-/* @flow */
-
-import * as nodeOps from 'weex/runtime/node-ops'
-import { createPatchFunction } from 'core/vdom/patch'
-import baseModules from 'core/vdom/modules/index'
-import platformModules from 'weex/runtime/modules/index'
-
-// the directive module should be applied last, after all
-// built-in modules have been applied.
-const modules = platformModules.concat(baseModules)
-
-export const patch: Function = createPatchFunction({
-  nodeOps,
-  modules,
-  LONG_LIST_THRESHOLD: 10
-})
diff --git a/1.Vue/src/platforms/weex/runtime/recycle-list/render-component-template.js b/1.Vue/src/platforms/weex/runtime/recycle-list/render-component-template.js
deleted file mode 100644
index 17e8c01..0000000
--- a/1.Vue/src/platforms/weex/runtime/recycle-list/render-component-template.js
+++ /dev/null
@@ -1,34 +0,0 @@
-/* @flow */
-
-import { warn } from 'core/util/debug'
-import { handleError } from 'core/util/error'
-import { RECYCLE_LIST_MARKER } from 'weex/util/index'
-import { createComponentInstanceForVnode } from 'core/vdom/create-component'
-import { resolveVirtualComponent } from './virtual-component'
-
-export function isRecyclableComponent (vnode: VNodeWithData): boolean {
-  return vnode.data.attrs
-    ? (RECYCLE_LIST_MARKER in vnode.data.attrs)
-    : false
-}
-
-export function renderRecyclableComponentTemplate (vnode: MountedComponentVNode): VNode {
-  // $flow-disable-line
-  delete vnode.data.attrs[RECYCLE_LIST_MARKER]
-  resolveVirtualComponent(vnode)
-  const vm = createComponentInstanceForVnode(vnode)
-  const render = (vm.$options: any)['@render']
-  if (render) {
-    try {
-      return render.call(vm)
-    } catch (err) {
-      handleError(err, vm, `@render`)
-    }
-  } else {
-    warn(
-      `@render function not defined on component used in <recycle-list>. ` +
-      `Make sure to declare \`recyclable="true"\` on the component's template.`,
-      vm
-    )
-  }
-}
diff --git a/1.Vue/src/platforms/weex/runtime/recycle-list/virtual-component.js b/1.Vue/src/platforms/weex/runtime/recycle-list/virtual-component.js
deleted file mode 100644
index e5498d2..0000000
--- a/1.Vue/src/platforms/weex/runtime/recycle-list/virtual-component.js
+++ /dev/null
@@ -1,136 +0,0 @@
-/* @flow */
-
-// https://github.com/Hanks10100/weex-native-directive/tree/master/component
-
-import { mergeOptions, isPlainObject, noop } from 'core/util/index'
-import Watcher from 'core/observer/watcher'
-import { initProxy } from 'core/instance/proxy'
-import { initState, getData } from 'core/instance/state'
-import { initRender } from 'core/instance/render'
-import { initEvents } from 'core/instance/events'
-import { initProvide, initInjections } from 'core/instance/inject'
-import { initLifecycle, callHook } from 'core/instance/lifecycle'
-import { initInternalComponent, resolveConstructorOptions } from 'core/instance/init'
-import { registerComponentHook, updateComponentData } from '../../util/index'
-
-let uid = 0
-
-// override Vue.prototype._init
-function initVirtualComponent (options: Object = {}) {
-  const vm: Component = this
-  const componentId = options.componentId
-
-  // virtual component uid
-  vm._uid = `virtual-component-${uid++}`
-
-  // a flag to avoid this being observed
-  vm._isVue = true
-  // merge options
-  if (options && options._isComponent) {
-    // optimize internal component instantiation
-    // since dynamic options merging is pretty slow, and none of the
-    // internal component options needs special treatment.
-    initInternalComponent(vm, options)
-  } else {
-    vm.$options = mergeOptions(
-      resolveConstructorOptions(vm.constructor),
-      options || {},
-      vm
-    )
-  }
-
-  /* istanbul ignore else */
-  if (process.env.NODE_ENV !== 'production') {
-    initProxy(vm)
-  } else {
-    vm._renderProxy = vm
-  }
-
-  vm._self = vm
-  initLifecycle(vm)
-  initEvents(vm)
-  initRender(vm)
-  callHook(vm, 'beforeCreate')
-  initInjections(vm) // resolve injections before data/props
-  initState(vm)
-  initProvide(vm) // resolve provide after data/props
-  callHook(vm, 'created')
-
-  // send initial data to native
-  const data = vm.$options.data
-  const params = typeof data === 'function'
-    ? getData(data, vm)
-    : data || {}
-  if (isPlainObject(params)) {
-    updateComponentData(componentId, params)
-  }
-
-  registerComponentHook(componentId, 'lifecycle', 'attach', () => {
-    callHook(vm, 'beforeMount')
-
-    const updateComponent = () => {
-      vm._update(vm._vnode, false)
-    }
-    new Watcher(vm, updateComponent, noop, null, true)
-
-    vm._isMounted = true
-    callHook(vm, 'mounted')
-  })
-
-  registerComponentHook(componentId, 'lifecycle', 'detach', () => {
-    vm.$destroy()
-  })
-}
-
-// override Vue.prototype._update
-function updateVirtualComponent (vnode?: VNode) {
-  const vm: Component = this
-  const componentId = vm.$options.componentId
-  if (vm._isMounted) {
-    callHook(vm, 'beforeUpdate')
-  }
-  vm._vnode = vnode
-  if (vm._isMounted && componentId) {
-    // TODO: data should be filtered and without bindings
-    const data = Object.assign({}, vm._data)
-    updateComponentData(componentId, data, () => {
-      callHook(vm, 'updated')
-    })
-  }
-}
-
-// listening on native callback
-export function resolveVirtualComponent (vnode: MountedComponentVNode): VNode {
-  const BaseCtor = vnode.componentOptions.Ctor
-  const VirtualComponent = BaseCtor.extend({})
-  const cid = VirtualComponent.cid
-  VirtualComponent.prototype._init = initVirtualComponent
-  VirtualComponent.prototype._update = updateVirtualComponent
-
-  vnode.componentOptions.Ctor = BaseCtor.extend({
-    beforeCreate () {
-      // const vm: Component = this
-
-      // TODO: listen on all events and dispatch them to the
-      // corresponding virtual components according to the componentId.
-      // vm._virtualComponents = {}
-      const createVirtualComponent = (componentId, propsData) => {
-        // create virtual component
-        // const subVm =
-        new VirtualComponent({
-          componentId,
-          propsData
-        })
-        // if (vm._virtualComponents) {
-        //   vm._virtualComponents[componentId] = subVm
-        // }
-      }
-
-      registerComponentHook(cid, 'lifecycle', 'create', createVirtualComponent)
-    },
-    beforeDestroy () {
-      delete this._virtualComponents
-    }
-  })
-}
-
diff --git a/1.Vue/src/platforms/weex/runtime/text-node.js b/1.Vue/src/platforms/weex/runtime/text-node.js
deleted file mode 100644
index 0720a05..0000000
--- a/1.Vue/src/platforms/weex/runtime/text-node.js
+++ /dev/null
@@ -1,9 +0,0 @@
-let latestNodeId = 1
-
-export default function TextNode (text) {
-  this.instanceId = ''
-  this.nodeId = latestNodeId++
-  this.parentNode = null
-  this.nodeType = 3
-  this.text = text
-}
diff --git a/1.Vue/src/platforms/weex/util/element.js b/1.Vue/src/platforms/weex/util/element.js
deleted file mode 100644
index 9753918..0000000
--- a/1.Vue/src/platforms/weex/util/element.js
+++ /dev/null
@@ -1,52 +0,0 @@
-/* @flow */
-
-// These util functions are split into its own file because Rollup cannot drop
-// makeMap() due to potential side effects, so these variables end up
-// bloating the web builds.
-
-import { makeMap, noop } from 'shared/util'
-
-export const isReservedTag = makeMap(
-  'template,script,style,element,content,slot,link,meta,svg,view,' +
-  'a,div,img,image,text,span,input,switch,textarea,spinner,select,' +
-  'slider,slider-neighbor,indicator,canvas,' +
-  'list,cell,header,loading,loading-indicator,refresh,scrollable,scroller,' +
-  'video,web,embed,tabbar,tabheader,datepicker,timepicker,marquee,countdown',
-  true
-)
-
-// Elements that you can, intentionally, leave open (and which close themselves)
-// more flexible than web
-export const canBeLeftOpenTag = makeMap(
-  'web,spinner,switch,video,textarea,canvas,' +
-  'indicator,marquee,countdown',
-  true
-)
-
-export const isRuntimeComponent = makeMap(
-  'richtext,transition,transition-group',
-  true
-)
-
-export const isUnaryTag = makeMap(
-  'embed,img,image,input,link,meta',
-  true
-)
-
-export function mustUseProp (): boolean {
-  return false
-}
-
-export function getTagNamespace (): void { }
-
-export function isUnknownElement (): boolean {
-  return false
-}
-
-export function query (el: string | Element, document: Object) {
-  // document is injected by weex factory wrapper
-  const placeholder = document.createComment('root')
-  placeholder.hasAttribute = placeholder.removeAttribute = noop // hack for patch
-  document.documentElement.appendChild(placeholder)
-  return placeholder
-}
diff --git a/1.Vue/src/platforms/weex/util/index.js b/1.Vue/src/platforms/weex/util/index.js
deleted file mode 100644
index 8181d70..0000000
--- a/1.Vue/src/platforms/weex/util/index.js
+++ /dev/null
@@ -1,40 +0,0 @@
-/* @flow */
-declare var document: WeexDocument;
-
-import { warn } from 'core/util/index'
-
-export const RECYCLE_LIST_MARKER = '@inRecycleList'
-
-// Register the component hook to weex native render engine.
-// The hook will be triggered by native, not javascript.
-export function registerComponentHook (
-  componentId: string,
-  type: string, // hook type, could be "lifecycle" or "instance"
-  hook: string, // hook name
-  fn: Function
-) {
-  if (!document || !document.taskCenter) {
-    warn(`Can't find available "document" or "taskCenter".`)
-    return
-  }
-  if (typeof document.taskCenter.registerHook === 'function') {
-    return document.taskCenter.registerHook(componentId, type, hook, fn)
-  }
-  warn(`Failed to register component hook "${type}@${hook}#${componentId}".`)
-}
-
-// Updates the state of the component to weex native render engine.
-export function updateComponentData (
-  componentId: string,
-  newData: Object | void,
-  callback?: Function
-) {
-  if (!document || !document.taskCenter) {
-    warn(`Can't find available "document" or "taskCenter".`)
-    return
-  }
-  if (typeof document.taskCenter.updateData === 'function') {
-    return document.taskCenter.updateData(componentId, newData, callback)
-  }
-  warn(`Failed to update component data (${componentId}).`)
-}
diff --git a/1.Vue/src/platforms/weex/util/parser.js b/1.Vue/src/platforms/weex/util/parser.js
deleted file mode 100644
index 081908e..0000000
--- a/1.Vue/src/platforms/weex/util/parser.js
+++ /dev/null
@@ -1,60 +0,0 @@
-/* @flow */
-
-// import { warn } from 'core/util/index'
-
-// this will be preserved during build
-// $flow-disable-line
-const acorn = require('acorn') // $flow-disable-line
-const walk = require('acorn/dist/walk') // $flow-disable-line
-const escodegen = require('escodegen')
-
-export function nodeToBinding (node: Object): any {
-  switch (node.type) {
-    case 'Literal': return node.value
-    case 'Identifier':
-    case 'UnaryExpression':
-    case 'BinaryExpression':
-    case 'LogicalExpression':
-    case 'ConditionalExpression':
-    case 'MemberExpression': return { '@binding': escodegen.generate(node) }
-    case 'ArrayExpression': return node.elements.map(_ => nodeToBinding(_))
-    case 'ObjectExpression': {
-      const object = {}
-      node.properties.forEach(prop => {
-        if (!prop.key || prop.key.type !== 'Identifier') {
-          return
-        }
-        const key = escodegen.generate(prop.key)
-        const value = nodeToBinding(prop.value)
-        if (key && value) {
-          object[key] = value
-        }
-      })
-      return object
-    }
-    default: {
-      // warn(`Not support ${node.type}: "${escodegen.generate(node)}"`)
-      return ''
-    }
-  }
-}
-
-export function generateBinding (exp: ?string): any {
-  if (exp && typeof exp === 'string') {
-    let ast = null
-    try {
-      ast = acorn.parse(`(${exp})`)
-    } catch (e) {
-      // warn(`Failed to parse the expression: "${exp}"`)
-      return ''
-    }
-
-    let output = ''
-    walk.simple(ast, {
-      Expression (node) {
-        output = nodeToBinding(node)
-      }
-    })
-    return output
-  }
-}
diff --git a/1.Vue/src/server/bundle-renderer/create-bundle-renderer.js b/1.Vue/src/server/bundle-renderer/create-bundle-renderer.js
deleted file mode 100644
index 05c60c3..0000000
--- a/1.Vue/src/server/bundle-renderer/create-bundle-renderer.js
+++ /dev/null
@@ -1,151 +0,0 @@
-/* @flow */
-
-import { createPromiseCallback } from '../util'
-import { createBundleRunner } from './create-bundle-runner'
-import type { Renderer, RenderOptions } from '../create-renderer'
-import { createSourceMapConsumers, rewriteErrorTrace } from './source-map-support'
-
-const fs = require('fs')
-const path = require('path')
-const PassThrough = require('stream').PassThrough
-
-const INVALID_MSG =
-  'Invalid server-rendering bundle format. Should be a string ' +
-  'or a bundle Object of type:\n\n' +
-`{
-  entry: string;
-  files: { [filename: string]: string; };
-  maps: { [filename: string]: string; };
-}\n`
-
-// The render bundle can either be a string (single bundled file)
-// or a bundle manifest object generated by vue-ssr-webpack-plugin.
-type RenderBundle = {
-  basedir?: string;
-  entry: string;
-  files: { [filename: string]: string; };
-  maps: { [filename: string]: string; };
-  modules?: { [filename: string]: Array<string> };
-};
-
-export function createBundleRendererCreator (
-  createRenderer: (options?: RenderOptions) => Renderer
-) {
-  return function createBundleRenderer (
-    bundle: string | RenderBundle,
-    rendererOptions?: RenderOptions = {}
-  ) {
-    let files, entry, maps
-    let basedir = rendererOptions.basedir
-
-    // load bundle if given filepath
-    if (
-      typeof bundle === 'string' &&
-      /\.js(on)?$/.test(bundle) &&
-      path.isAbsolute(bundle)
-    ) {
-      if (fs.existsSync(bundle)) {
-        const isJSON = /\.json$/.test(bundle)
-        basedir = basedir || path.dirname(bundle)
-        bundle = fs.readFileSync(bundle, 'utf-8')
-        if (isJSON) {
-          try {
-            bundle = JSON.parse(bundle)
-          } catch (e) {
-            throw new Error(`Invalid JSON bundle file: ${bundle}`)
-          }
-        }
-      } else {
-        throw new Error(`Cannot locate bundle file: ${bundle}`)
-      }
-    }
-
-    if (typeof bundle === 'object') {
-      entry = bundle.entry
-      files = bundle.files
-      basedir = basedir || bundle.basedir
-      maps = createSourceMapConsumers(bundle.maps)
-      if (typeof entry !== 'string' || typeof files !== 'object') {
-        throw new Error(INVALID_MSG)
-      }
-    } else if (typeof bundle === 'string') {
-      entry = '__vue_ssr_bundle__'
-      files = { '__vue_ssr_bundle__': bundle }
-      maps = {}
-    } else {
-      throw new Error(INVALID_MSG)
-    }
-
-    const renderer = createRenderer(rendererOptions)
-
-    const run = createBundleRunner(
-      entry,
-      files,
-      basedir,
-      rendererOptions.runInNewContext
-    )
-
-    return {
-      renderToString: (context?: Object, cb: any) => {
-        if (typeof context === 'function') {
-          cb = context
-          context = {}
-        }
-
-        let promise
-        if (!cb) {
-          ({ promise, cb } = createPromiseCallback())
-        }
-
-        run(context).catch(err => {
-          rewriteErrorTrace(err, maps)
-          cb(err)
-        }).then(app => {
-          if (app) {
-            renderer.renderToString(app, context, (err, res) => {
-              rewriteErrorTrace(err, maps)
-              cb(err, res)
-            })
-          }
-        })
-
-        return promise
-      },
-
-      renderToStream: (context?: Object) => {
-        const res = new PassThrough()
-        run(context).catch(err => {
-          rewriteErrorTrace(err, maps)
-          // avoid emitting synchronously before user can
-          // attach error listener
-          process.nextTick(() => {
-            res.emit('error', err)
-          })
-        }).then(app => {
-          if (app) {
-            const renderStream = renderer.renderToStream(app, context)
-
-            renderStream.on('error', err => {
-              rewriteErrorTrace(err, maps)
-              res.emit('error', err)
-            })
-
-            // relay HTMLStream special events
-            if (rendererOptions && rendererOptions.template) {
-              renderStream.on('beforeStart', () => {
-                res.emit('beforeStart')
-              })
-              renderStream.on('beforeEnd', () => {
-                res.emit('beforeEnd')
-              })
-            }
-
-            renderStream.pipe(res)
-          }
-        })
-
-        return res
-      }
-    }
-  }
-}
diff --git a/1.Vue/src/server/bundle-renderer/create-bundle-runner.js b/1.Vue/src/server/bundle-renderer/create-bundle-runner.js
deleted file mode 100644
index 16c33c4..0000000
--- a/1.Vue/src/server/bundle-renderer/create-bundle-runner.js
+++ /dev/null
@@ -1,150 +0,0 @@
-import { isPlainObject } from 'shared/util'
-
-const vm = require('vm')
-const path = require('path')
-const resolve = require('resolve')
-const NativeModule = require('module')
-
-function createSandbox (context) {
-  const sandbox = {
-    Buffer,
-    console,
-    process,
-    setTimeout,
-    setInterval,
-    setImmediate,
-    clearTimeout,
-    clearInterval,
-    clearImmediate,
-    __VUE_SSR_CONTEXT__: context
-  }
-  sandbox.global = sandbox
-  return sandbox
-}
-
-function compileModule (files, basedir, runInNewContext) {
-  const compiledScripts = {}
-  const resolvedModules = {}
-
-  function getCompiledScript (filename) {
-    if (compiledScripts[filename]) {
-      return compiledScripts[filename]
-    }
-    const code = files[filename]
-    const wrapper = NativeModule.wrap(code)
-    const script = new vm.Script(wrapper, {
-      filename,
-      displayErrors: true
-    })
-    compiledScripts[filename] = script
-    return script
-  }
-
-  function evaluateModule (filename, sandbox, evaluatedFiles = {}) {
-    if (evaluatedFiles[filename]) {
-      return evaluatedFiles[filename]
-    }
-
-    const script = getCompiledScript(filename)
-    const compiledWrapper = runInNewContext === false
-      ? script.runInThisContext()
-      : script.runInNewContext(sandbox)
-    const m = { exports: {}}
-    const r = file => {
-      file = path.posix.join('.', file)
-      if (files[file]) {
-        return evaluateModule(file, sandbox, evaluatedFiles)
-      } else if (basedir) {
-        return require(
-          resolvedModules[file] ||
-          (resolvedModules[file] = resolve.sync(file, { basedir }))
-        )
-      } else {
-        return require(file)
-      }
-    }
-    compiledWrapper.call(m.exports, m.exports, r, m)
-
-    const res = Object.prototype.hasOwnProperty.call(m.exports, 'default')
-      ? m.exports.default
-      : m.exports
-    evaluatedFiles[filename] = res
-    return res
-  }
-  return evaluateModule
-}
-
-function deepClone (val) {
-  if (isPlainObject(val)) {
-    const res = {}
-    for (const key in val) {
-      res[key] = deepClone(val[key])
-    }
-    return res
-  } else if (Array.isArray(val)) {
-    return val.slice()
-  } else {
-    return val
-  }
-}
-
-export function createBundleRunner (entry, files, basedir, runInNewContext) {
-  const evaluate = compileModule(files, basedir, runInNewContext)
-  if (runInNewContext !== false && runInNewContext !== 'once') {
-    // new context mode: creates a fresh context and re-evaluate the bundle
-    // on each render. Ensures entire application state is fresh for each
-    // render, but incurs extra evaluation cost.
-    return (userContext = {}) => new Promise(resolve => {
-      userContext._registeredComponents = new Set()
-      const res = evaluate(entry, createSandbox(userContext))
-      resolve(typeof res === 'function' ? res(userContext) : res)
-    })
-  } else {
-    // direct mode: instead of re-evaluating the whole bundle on
-    // each render, it simply calls the exported function. This avoids the
-    // module evaluation costs but requires the source code to be structured
-    // slightly differently.
-    let runner // lazy creation so that errors can be caught by user
-    let initialContext
-    return (userContext = {}) => new Promise(resolve => {
-      if (!runner) {
-        const sandbox = runInNewContext === 'once'
-          ? createSandbox()
-          : global
-        // the initial context is only used for collecting possible non-component
-        // styles injected by vue-style-loader.
-        initialContext = sandbox.__VUE_SSR_CONTEXT__ = {}
-        runner = evaluate(entry, sandbox)
-        // On subsequent renders, __VUE_SSR_CONTEXT__ will not be available
-        // to prevent cross-request pollution.
-        delete sandbox.__VUE_SSR_CONTEXT__
-        if (typeof runner !== 'function') {
-          throw new Error(
-            'bundle export should be a function when using ' +
-            '{ runInNewContext: false }.'
-          )
-        }
-      }
-      userContext._registeredComponents = new Set()
-
-      // vue-style-loader styles imported outside of component lifecycle hooks
-      if (initialContext._styles) {
-        userContext._styles = deepClone(initialContext._styles)
-        // #6353 ensure "styles" is exposed even if no styles are injected
-        // in component lifecycles.
-        // the renderStyles fn is exposed by vue-style-loader >= 3.0.3
-        const renderStyles = initialContext._renderStyles
-        if (renderStyles) {
-          Object.defineProperty(userContext, 'styles', {
-            enumerable: true,
-            get () {
-              return renderStyles(userContext._styles)
-            }
-          })
-        }
-      }
-
-      resolve(runner(userContext))
-    })
-  }
-}
diff --git a/1.Vue/src/server/bundle-renderer/source-map-support.js b/1.Vue/src/server/bundle-renderer/source-map-support.js
deleted file mode 100644
index 1010532..0000000
--- a/1.Vue/src/server/bundle-renderer/source-map-support.js
+++ /dev/null
@@ -1,45 +0,0 @@
-/* @flow */
-
-const SourceMapConsumer = require('source-map').SourceMapConsumer
-
-const filenameRE = /\(([^)]+\.js):(\d+):(\d+)\)$/
-
-export function createSourceMapConsumers (rawMaps: Object) {
-  const maps = {}
-  Object.keys(rawMaps).forEach(file => {
-    maps[file] = new SourceMapConsumer(rawMaps[file])
-  })
-  return maps
-}
-
-export function rewriteErrorTrace (e: any, mapConsumers: {
-  [key: string]: SourceMapConsumer
-}) {
-  if (e && typeof e.stack === 'string') {
-    e.stack = e.stack.split('\n').map(line => {
-      return rewriteTraceLine(line, mapConsumers)
-    }).join('\n')
-  }
-}
-
-function rewriteTraceLine (trace: string, mapConsumers: {
-  [key: string]: SourceMapConsumer
-}) {
-  const m = trace.match(filenameRE)
-  const map = m && mapConsumers[m[1]]
-  if (m != null && map) {
-    const originalPosition = map.originalPositionFor({
-      line: Number(m[2]),
-      column: Number(m[3])
-    })
-    if (originalPosition.source != null) {
-      const { source, line, column } = originalPosition
-      const mappedPosition = `(${source.replace(/^webpack:\/\/\//, '')}:${String(line)}:${String(column)})`
-      return trace.replace(filenameRE, mappedPosition)
-    } else {
-      return trace
-    }
-  } else {
-    return trace
-  }
-}
diff --git a/1.Vue/src/server/create-basic-renderer.js b/1.Vue/src/server/create-basic-renderer.js
deleted file mode 100644
index 2d53976..0000000
--- a/1.Vue/src/server/create-basic-renderer.js
+++ /dev/null
@@ -1,37 +0,0 @@
-/* @flow */
-
-import { createWriteFunction } from './write'
-import { createRenderFunction } from './render'
-import type { RenderOptions } from './create-renderer'
-
-export function createBasicRenderer ({
-  modules = [],
-  directives = {},
-  isUnaryTag = (() => false),
-  cache
-}: RenderOptions = {}) {
-  const render = createRenderFunction(modules, directives, isUnaryTag, cache)
-
-  return function renderToString (
-    component: Component,
-    context: any,
-    done: any
-  ): void {
-    if (typeof context === 'function') {
-      done = context
-      context = {}
-    }
-    let result = ''
-    const write = createWriteFunction(text => {
-      result += text
-      return false
-    }, done)
-    try {
-      render(component, write, context, () => {
-        done(null, result)
-      })
-    } catch (e) {
-      done(e)
-    }
-  }
-}
diff --git a/1.Vue/src/server/create-renderer.js b/1.Vue/src/server/create-renderer.js
deleted file mode 100644
index 502b6fa..0000000
--- a/1.Vue/src/server/create-renderer.js
+++ /dev/null
@@ -1,152 +0,0 @@
-/* @flow */
-
-import RenderStream from './render-stream'
-import { createWriteFunction } from './write'
-import { createRenderFunction } from './render'
-import { createPromiseCallback } from './util'
-import TemplateRenderer from './template-renderer/index'
-import type { ClientManifest } from './template-renderer/index'
-
-export type Renderer = {
-  renderToString: (component: Component, context: any, cb: any) => ?Promise<string>;
-  renderToStream: (component: Component, context?: Object) => stream$Readable;
-};
-
-type RenderCache = {
-  get: (key: string, cb?: Function) => string | void;
-  set: (key: string, val: string) => void;
-  has?: (key: string, cb?: Function) => boolean | void;
-};
-
-export type RenderOptions = {
-  modules?: Array<(vnode: VNode) => ?string>;
-  directives?: Object;
-  isUnaryTag?: Function;
-  cache?: RenderCache;
-  template?: string | (content: string, context: any) => string;
-  inject?: boolean;
-  basedir?: string;
-  shouldPreload?: Function;
-  shouldPrefetch?: Function;
-  clientManifest?: ClientManifest;
-  serializer?: Function;
-  runInNewContext?: boolean | 'once';
-};
-
-export function createRenderer ({
-  modules = [],
-  directives = {},
-  isUnaryTag = (() => false),
-  template,
-  inject,
-  cache,
-  shouldPreload,
-  shouldPrefetch,
-  clientManifest,
-  serializer
-}: RenderOptions = {}): Renderer {
-  const render = createRenderFunction(modules, directives, isUnaryTag, cache)
-  const templateRenderer = new TemplateRenderer({
-    template,
-    inject,
-    shouldPreload,
-    shouldPrefetch,
-    clientManifest,
-    serializer
-  })
-
-  return {
-    renderToString (
-      component: Component,
-      context: any,
-      cb: any
-    ): ?Promise<string> {
-      if (typeof context === 'function') {
-        cb = context
-        context = {}
-      }
-      if (context) {
-        templateRenderer.bindRenderFns(context)
-      }
-
-      // no callback, return Promise
-      let promise
-      if (!cb) {
-        ({ promise, cb } = createPromiseCallback())
-      }
-
-      let result = ''
-      const write = createWriteFunction(text => {
-        result += text
-        return false
-      }, cb)
-      try {
-        render(component, write, context, err => {
-          if (err) {
-            return cb(err)
-          }
-          if (context && context.rendered) {
-            context.rendered(context)
-          }
-          if (template) {
-            try {
-              const res = templateRenderer.render(result, context)
-              if (typeof res !== 'string') {
-                // function template returning promise
-                res
-                  .then(html => cb(null, html))
-                  .catch(cb)
-              } else {
-                cb(null, res)
-              }
-            } catch (e) {
-              cb(e)
-            }
-          } else {
-            cb(null, result)
-          }
-        })
-      } catch (e) {
-        cb(e)
-      }
-
-      return promise
-    },
-
-    renderToStream (
-      component: Component,
-      context?: Object
-    ): stream$Readable {
-      if (context) {
-        templateRenderer.bindRenderFns(context)
-      }
-      const renderStream = new RenderStream((write, done) => {
-        render(component, write, context, done)
-      })
-      if (!template) {
-        if (context && context.rendered) {
-          const rendered = context.rendered
-          renderStream.once('beforeEnd', () => {
-            rendered(context)
-          })
-        }
-        return renderStream
-      } else if (typeof template === 'function') {
-        throw new Error(`function template is only supported in renderToString.`)
-      } else {
-        const templateStream = templateRenderer.createStream(context)
-        renderStream.on('error', err => {
-          templateStream.emit('error', err)
-        })
-        renderStream.pipe(templateStream)
-        if (context && context.rendered) {
-          const rendered = context.rendered
-          renderStream.once('beforeEnd', () => {
-            rendered(context)
-          })
-        }
-        return templateStream
-      }
-    }
-  }
-}
diff --git a/1.Vue/src/server/optimizing-compiler/codegen.js b/1.Vue/src/server/optimizing-compiler/codegen.js
deleted file mode 100644
index 9399761..0000000
--- a/1.Vue/src/server/optimizing-compiler/codegen.js
+++ /dev/null
@@ -1,264 +0,0 @@
-/* @flow */
-
-// The SSR codegen is essentially extending the default codegen to handle
-// SSR-optimizable nodes and turn them into string render fns. In cases where
-// a node is not optimizable it simply falls back to the default codegen.
-
-import {
-  genIf,
-  genFor,
-  genData,
-  genText,
-  genElement,
-  genChildren,
-  CodegenState
-} from 'compiler/codegen/index'
-
-import {
-  genAttrSegments,
-  genDOMPropSegments,
-  genClassSegments,
-  genStyleSegments,
-  applyModelTransform
-} from './modules'
-
-import { escape } from 'web/server/util'
-import { optimizability } from './optimizer'
-import type { CodegenResult } from 'compiler/codegen/index'
-
-export type StringSegment = {
-  type: number;
-  value: string;
-};
-
-// segment types
-export const RAW = 0
-export const INTERPOLATION = 1
-export const EXPRESSION = 2
-
-export function generate (
-  ast: ASTElement | void,
-  options: CompilerOptions
-): CodegenResult {
-  const state = new CodegenState(options)
-  const code = ast ? genSSRElement(ast, state) : '_c("div")'
-  return {
-    render: `with(this){return ${code}}`,
-    staticRenderFns: state.staticRenderFns
-  }
-}
-
-function genSSRElement (el: ASTElement, state: CodegenState): string {
-  if (el.for && !el.forProcessed) {
-    return genFor(el, state, genSSRElement)
-  } else if (el.if && !el.ifProcessed) {
-    return genIf(el, state, genSSRElement)
-  } else if (el.tag === 'template' && !el.slotTarget) {
-    return el.ssrOptimizability === optimizability.FULL
-      ? genChildrenAsStringNode(el, state)
-      : genSSRChildren(el, state) || 'void 0'
-  }
-
-  switch (el.ssrOptimizability) {
-    case optimizability.FULL:
-      // stringify whole tree
-      return genStringElement(el, state)
-    case optimizability.SELF:
-      // stringify self and check children
-      return genStringElementWithChildren(el, state)
-    case optimizability.CHILDREN:
-      // generate self as VNode and stringify children
-      return genNormalElement(el, state, true)
-    case optimizability.PARTIAL:
-      // generate self as VNode and check children
-      return genNormalElement(el, state, false)
-    default:
-      // bail whole tree
-      return genElement(el, state)
-  }
-}
-
-function genNormalElement (el, state, stringifyChildren) {
-  const data = el.plain ? undefined : genData(el, state)
-  const children = stringifyChildren
-    ? `[${genChildrenAsStringNode(el, state)}]`
-    : genSSRChildren(el, state, true)
-  return `_c('${el.tag}'${
-    data ? `,${data}` : ''
-  }${
-    children ? `,${children}` : ''
-  })`
-}
-
-function genSSRChildren (el, state, checkSkip) {
-  return genChildren(el, state, checkSkip, genSSRElement, genSSRNode)
-}
-
-function genSSRNode (el, state) {
-  return el.type === 1
-    ? genSSRElement(el, state)
-    : genText(el)
-}
-
-function genChildrenAsStringNode (el, state) {
-  return el.children.length
-    ? `_ssrNode(${flattenSegments(childrenToSegments(el, state))})`
-    : ''
-}
-
-function genStringElement (el, state) {
-  return `_ssrNode(${elementToString(el, state)})`
-}
-
-function genStringElementWithChildren (el, state) {
-  const children = genSSRChildren(el, state, true)
-  return `_ssrNode(${
-    flattenSegments(elementToOpenTagSegments(el, state))
-  },"</${el.tag}>"${
-    children ? `,${children}` : ''
-  })`
-}
-
-function elementToString (el, state) {
-  return `(${flattenSegments(elementToSegments(el, state))})`
-}
-
-function elementToSegments (el, state): Array<StringSegment> {
-  // v-for / v-if
-  if (el.for && !el.forProcessed) {
-    el.forProcessed = true
-    return [{
-      type: EXPRESSION,
-      value: genFor(el, state, elementToString, '_ssrList')
-    }]
-  } else if (el.if && !el.ifProcessed) {
-    el.ifProcessed = true
-    return [{
-      type: EXPRESSION,
-      value: genIf(el, state, elementToString, '"<!---->"')
-    }]
-  } else if (el.tag === 'template') {
-    return childrenToSegments(el, state)
-  }
-
-  const openSegments = elementToOpenTagSegments(el, state)
-  const childrenSegments = childrenToSegments(el, state)
-  const { isUnaryTag } = state.options
-  const close = (isUnaryTag && isUnaryTag(el.tag))
-    ? []
-    : [{ type: RAW, value: `</${el.tag}>` }]
-  return openSegments.concat(childrenSegments, close)
-}
-
-function elementToOpenTagSegments (el, state): Array<StringSegment> {
-  applyModelTransform(el, state)
-  let binding
-  const segments = [{ type: RAW, value: `<${el.tag}` }]
-  // attrs
-  if (el.attrs) {
-    segments.push.apply(segments, genAttrSegments(el.attrs))
-  }
-  // domProps
-  if (el.props) {
-    segments.push.apply(segments, genDOMPropSegments(el.props, el.attrs))
-  }
-  // v-bind="object"
-  if ((binding = el.attrsMap['v-bind'])) {
-    segments.push({ type: EXPRESSION, value: `_ssrAttrs(${binding})` })
-  }
-  // v-bind.prop="object"
-  if ((binding = el.attrsMap['v-bind.prop'])) {
-    segments.push({ type: EXPRESSION, value: `_ssrDOMProps(${binding})` })
-  }
-  // class
-  if (el.staticClass || el.classBinding) {
-    segments.push.apply(
-      segments,
-      genClassSegments(el.staticClass, el.classBinding)
-    )
-  }
-  // style & v-show
-  if (el.staticStyle || el.styleBinding || el.attrsMap['v-show']) {
-    segments.push.apply(
-      segments,
-      genStyleSegments(
-        el.attrsMap.style,
-        el.staticStyle,
-        el.styleBinding,
-        el.attrsMap['v-show']
-      )
-    )
-  }
-  // _scopedId
-  if (state.options.scopeId) {
-    segments.push({ type: RAW, value: ` ${state.options.scopeId}` })
-  }
-  segments.push({ type: RAW, value: `>` })
-  return segments
-}
-
-function childrenToSegments (el, state): Array<StringSegment> {
-  let binding
-  if ((binding = el.attrsMap['v-html'])) {
-    return [{ type: EXPRESSION, value: `_s(${binding})` }]
-  }
-  if ((binding = el.attrsMap['v-text'])) {
-    return [{ type: INTERPOLATION, value: `_s(${binding})` }]
-  }
-  if (el.tag === 'textarea' && (binding = el.attrsMap['v-model'])) {
-    return [{ type: INTERPOLATION, value: `_s(${binding})` }]
-  }
-  return el.children
-    ? nodesToSegments(el.children, state)
-    : []
-}
-
-function nodesToSegments (
-  children: Array<ASTNode>,
-  state: CodegenState
-): Array<StringSegment> {
-  const segments = []
-  for (let i = 0; i < children.length; i++) {
-    const c = children[i]
-    if (c.type === 1) {
-      segments.push.apply(segments, elementToSegments(c, state))
-    } else if (c.type === 2) {
-      segments.push({ type: INTERPOLATION, value: c.expression })
-    } else if (c.type === 3) {
-      let text = escape(c.text)
-      if (c.isComment) {
-        text = '<!--' + text + '-->'
-      }
-      segments.push({ type: RAW, value: text })
-    }
-  }
-  return segments
-}
-
-function flattenSegments (segments: Array<StringSegment>): string {
-  const mergedSegments = []
-  let textBuffer = ''
-
-  const pushBuffer = () => {
-    if (textBuffer) {
-      mergedSegments.push(JSON.stringify(textBuffer))
-      textBuffer = ''
-    }
-  }
-
-  for (let i = 0; i < segments.length; i++) {
-    const s = segments[i]
-    if (s.type === RAW) {
-      textBuffer += s.value
-    } else if (s.type === INTERPOLATION) {
-      pushBuffer()
-      mergedSegments.push(`_ssrEscape(${s.value})`)
-    } else if (s.type === EXPRESSION) {
-      pushBuffer()
-      mergedSegments.push(`(${s.value})`)
-    }
-  }
-  pushBuffer()
-
-  return mergedSegments.join('+')
-}
diff --git a/1.Vue/src/server/optimizing-compiler/index.js b/1.Vue/src/server/optimizing-compiler/index.js
deleted file mode 100644
index 893630d..0000000
--- a/1.Vue/src/server/optimizing-compiler/index.js
+++ /dev/null
@@ -1,20 +0,0 @@
-/* @flow */
-
-import { parse } from 'compiler/parser/index'
-import { generate } from './codegen'
-import { optimize } from './optimizer'
-import { createCompilerCreator } from 'compiler/create-compiler'
-
-export const createCompiler = createCompilerCreator(function baseCompile (
-  template: string,
-  options: CompilerOptions
-): CompiledResult {
-  const ast = parse(template.trim(), options)
-  optimize(ast, options)
-  const code = generate(ast, options)
-  return {
-    ast,
-    render: code.render,
-    staticRenderFns: code.staticRenderFns
-  }
-})
diff --git a/1.Vue/src/server/optimizing-compiler/modules.js b/1.Vue/src/server/optimizing-compiler/modules.js
deleted file mode 100644
index a1dcfe5..0000000
--- a/1.Vue/src/server/optimizing-compiler/modules.js
+++ /dev/null
@@ -1,124 +0,0 @@
-/* @flow */
-
-import {
-  RAW,
-  // INTERPOLATION,
-  EXPRESSION
-} from './codegen'
-
-import {
-  propsToAttrMap,
-  isRenderableAttr
-} from 'web/server/util'
-
-import {
-  isBooleanAttr,
-  isEnumeratedAttr
-} from 'web/util/attrs'
-
-import type { StringSegment } from './codegen'
-import type { CodegenState } from 'compiler/codegen/index'
-
-const plainStringRE = /^"(?:[^"\\]|\\.)*"$|^'(?:[^'\\]|\\.)*'$/
-
-// let the model AST transform translate v-model into appropriate
-// props bindings
-export function applyModelTransform (el: ASTElement, state: CodegenState) {
-  if (el.directives) {
-    for (let i = 0; i < el.directives.length; i++) {
-      const dir = el.directives[i]
-      if (dir.name === 'model') {
-        state.directives.model(el, dir, state.warn)
-        // remove value for textarea as its converted to text
-        if (el.tag === 'textarea' && el.props) {
-          el.props = el.props.filter(p => p.name !== 'value')
-        }
-        break
-      }
-    }
-  }
-}
-
-export function genAttrSegments (
-  attrs: Array<ASTAttr>
-): Array<StringSegment> {
-  return attrs.map(({ name, value }) => genAttrSegment(name, value))
-}
-
-export function genDOMPropSegments (
-  props: Array<ASTAttr>,
-  attrs: ?Array<ASTAttr>
-): Array<StringSegment> {
-  const segments = []
-  props.forEach(({ name, value }) => {
-    name = propsToAttrMap[name] || name.toLowerCase()
-    if (isRenderableAttr(name) &&
-      !(attrs && attrs.some(a => a.name === name))
-    ) {
-      segments.push(genAttrSegment(name, value))
-    }
-  })
-  return segments
-}
-
-function genAttrSegment (name: string, value: string): StringSegment {
-  if (plainStringRE.test(value)) {
-    // force double quote
-    value = value.replace(/^'|'$/g, '"')
-    // force enumerated attr to "true"
-    if (isEnumeratedAttr(name) && value !== `"false"`) {
-      value = `"true"`
-    }
-    return {
-      type: RAW,
-      value: isBooleanAttr(name)
-        ? ` ${name}="${name}"`
-        : value === '""'
-          ? ` ${name}`
-          : ` ${name}="${JSON.parse(value)}"`
-    }
-  } else {
-    return {
-      type: EXPRESSION,
-      value: `_ssrAttr(${JSON.stringify(name)},${value})`
-    }
-  }
-}
-
-export function genClassSegments (
-  staticClass: ?string,
-  classBinding: ?string
-): Array<StringSegment> {
-  if (staticClass && !classBinding) {
-    return [{ type: RAW, value: ` class="${JSON.parse(staticClass)}"` }]
-  } else {
-    return [{
-      type: EXPRESSION,
-      value: `_ssrClass(${staticClass || 'null'},${classBinding || 'null'})`
-    }]
-  }
-}
-
-export function genStyleSegments (
-  staticStyle: ?string,
-  parsedStaticStyle: ?string,
-  styleBinding: ?string,
-  vShowExpression: ?string
-): Array<StringSegment> {
-  if (staticStyle && !styleBinding && !vShowExpression) {
-    return [{ type: RAW, value: ` style=${JSON.stringify(staticStyle)}` }]
-  } else {
-    return [{
-      type: EXPRESSION,
-      value: `_ssrStyle(${
-        parsedStaticStyle || 'null'
-      },${
-        styleBinding || 'null'
-      }, ${
-        vShowExpression
-          ? `{ display: (${vShowExpression}) ? '' : 'none' }`
-          : 'null'
-      })`
-    }]
-  }
-}
diff --git a/1.Vue/src/server/optimizing-compiler/optimizer.js b/1.Vue/src/server/optimizing-compiler/optimizer.js
deleted file mode 100644
index d89cbd0..0000000
--- a/1.Vue/src/server/optimizing-compiler/optimizer.js
+++ /dev/null
@@ -1,141 +0,0 @@
-/* @flow */
-
-/**
- * In SSR, the vdom tree is generated only once and never patched, so
- * we can optimize most element / trees into plain string render functions.
- * The SSR optimizer walks the AST tree to detect optimizable elements and trees.
- *
- * The criteria for SSR optimizability is quite a bit looser than static tree
- * detection (which is designed for client re-render). In SSR we bail only for
- * components/slots/custom directives.
- */
-
-import { no, makeMap, isBuiltInTag } from 'shared/util'
-
-// optimizability constants
-export const optimizability = {
-  FALSE: 0,    // whole sub tree un-optimizable
-  FULL: 1,     // whole sub tree optimizable
-  SELF: 2,     // self optimizable but has some un-optimizable children
-  CHILDREN: 3, // self un-optimizable but have fully optimizable children
-  PARTIAL: 4   // self un-optimizable with some un-optimizable children
-}
-
-let isPlatformReservedTag
-
-export function optimize (root: ?ASTElement, options: CompilerOptions) {
-  if (!root) return
-  isPlatformReservedTag = options.isReservedTag || no
-  walk(root, true)
-}
-
-function walk (node: ASTNode, isRoot?: boolean) {
-  if (isUnOptimizableTree(node)) {
-    node.ssrOptimizability = optimizability.FALSE
-    return
-  }
-  // root node or nodes with custom directives should always be a VNode
-  const selfUnoptimizable = isRoot || hasCustomDirective(node)
-  const check = child => {
-    if (child.ssrOptimizability !== optimizability.FULL) {
-      node.ssrOptimizability = selfUnoptimizable
-        ? optimizability.PARTIAL
-        : optimizability.SELF
-    }
-  }
-  if (selfUnoptimizable) {
-    node.ssrOptimizability = optimizability.CHILDREN
-  }
-  if (node.type === 1) {
-    for (let i = 0, l = node.children.length; i < l; i++) {
-      const child = node.children[i]
-      walk(child)
-      check(child)
-    }
-    if (node.ifConditions) {
-      for (let i = 1, l = node.ifConditions.length; i < l; i++) {
-        const block = node.ifConditions[i].block
-        walk(block, isRoot)
-        check(block)
-      }
-    }
-    if (node.ssrOptimizability == null ||
-      (!isRoot && (node.attrsMap['v-html'] || node.attrsMap['v-text']))
-    ) {
-      node.ssrOptimizability = optimizability.FULL
-    } else {
-      node.children = optimizeSiblings(node)
-    }
-  } else {
-    node.ssrOptimizability = optimizability.FULL
-  }
-}
-
-function optimizeSiblings (el) {
-  const children = el.children
-  const optimizedChildren = []
-
-  let currentOptimizableGroup = []
-  const pushGroup = () => {
-    if (currentOptimizableGroup.length) {
-      optimizedChildren.push({
-        type: 1,
-        parent: el,
-        tag: 'template',
-        attrsList: [],
-        attrsMap: {},
-        rawAttrsMap: {},
-        children: currentOptimizableGroup,
-        ssrOptimizability: optimizability.FULL
-      })
-    }
-    currentOptimizableGroup = []
-  }
-
-  for (let i = 0; i < children.length; i++) {
-    const c = children[i]
-    if (c.ssrOptimizability === optimizability.FULL) {
-      currentOptimizableGroup.push(c)
-    } else {
-      // wrap fully-optimizable adjacent siblings inside a template tag
-      // so that they can be optimized into a single ssrNode by codegen
-      pushGroup()
-      optimizedChildren.push(c)
-    }
-  }
-  pushGroup()
-  return optimizedChildren
-}
-
-function isUnOptimizableTree (node: ASTNode): boolean {
-  if (node.type === 2 || node.type === 3) { // text or expression
-    return false
-  }
-  return (
-    isBuiltInTag(node.tag) || // built-in (slot, component)
-    !isPlatformReservedTag(node.tag) || // custom component
-    !!node.component || // "is" component
-    isSelectWithModel(node) // <select v-model> requires runtime inspection
-  )
-}
-
-const isBuiltInDir = makeMap('text,html,show,on,bind,model,pre,cloak,once')
-
-function hasCustomDirective (node: ASTNode): ?boolean {
-  return (
-    node.type === 1 &&
-    node.directives &&
-    node.directives.some(d => !isBuiltInDir(d.name))
-  )
-}
-
-// <select v-model> cannot be optimized because it requires a runtime check
-// to determine proper selected option
-function isSelectWithModel (node: ASTNode): boolean {
-  return (
-    node.type === 1 &&
-    node.tag === 'select' &&
-    node.directives != null &&
-    node.directives.some(d => d.name === 'model')
-  )
-}
diff --git a/1.Vue/src/server/optimizing-compiler/runtime-helpers.js b/1.Vue/src/server/optimizing-compiler/runtime-helpers.js
deleted file mode 100644
index 6f65de0..0000000
--- a/1.Vue/src/server/optimizing-compiler/runtime-helpers.js
+++ /dev/null
@@ -1,150 +0,0 @@
-/* @flow */
-
-import { escape, isSSRUnsafeAttr } from 'web/server/util'
-import { isObject, extend } from 'shared/util'
-import { renderAttr } from 'web/server/modules/attrs'
-import { renderClass } from 'web/util/class'
-import { genStyle } from 'web/server/modules/style'
-import { normalizeStyleBinding } from 'web/util/style'
-
-import {
-  normalizeChildren,
-  simpleNormalizeChildren
-} from 'core/vdom/helpers/normalize-children'
-
-import {
-  propsToAttrMap,
-  isRenderableAttr
-} from 'web/server/util'
-
-const ssrHelpers = {
-  _ssrEscape: escape,
-  _ssrNode: renderStringNode,
-  _ssrList: renderStringList,
-  _ssrAttr: renderAttr,
-  _ssrAttrs: renderAttrs,
-  _ssrDOMProps: renderDOMProps,
-  _ssrClass: renderSSRClass,
-  _ssrStyle: renderSSRStyle
-}
-
-export function installSSRHelpers (vm: Component) {
-  if (vm._ssrNode) {
-    return
-  }
-  let Vue = vm.constructor
-  while (Vue.super) {
-    Vue = Vue.super
-  }
-  extend(Vue.prototype, ssrHelpers)
-  if (Vue.FunctionalRenderContext) {
-    extend(Vue.FunctionalRenderContext.prototype, ssrHelpers)
-  }
-}
-
-class StringNode {
-  isString: boolean;
-  open: string;
-  close: ?string;
-  children: ?Array<any>;
-
-  constructor (
-    open: string,
-    close?: string,
-    children?: Array<any>,
-    normalizationType?: number
-  ) {
-    this.isString = true
-    this.open = open
-    this.close = close
-    if (children) {
-      this.children = normalizationType === 1
-        ? simpleNormalizeChildren(children)
-        : normalizationType === 2
-          ? normalizeChildren(children)
-          : children
-    } else {
-      this.children = void 0
-    }
-  }
-}
-
-function renderStringNode (
-  open: string,
-  close?: string,
-  children?: Array<any>,
-  normalizationType?: number
-): StringNode {
-  return new StringNode(open, close, children, normalizationType)
-}
-
-function renderStringList (
-  val: any,
-  render: (
-    val: any,
-    keyOrIndex: string | number,
-    index?: number
-  ) => string
-): string {
-  let ret = ''
-  let i, l, keys, key
-  if (Array.isArray(val) || typeof val === 'string') {
-    for (i = 0, l = val.length; i < l; i++) {
-      ret += render(val[i], i)
-    }
-  } else if (typeof val === 'number') {
-    for (i = 0; i < val; i++) {
-      ret += render(i + 1, i)
-    }
-  } else if (isObject(val)) {
-    keys = Object.keys(val)
-    for (i = 0, l = keys.length; i < l; i++) {
-      key = keys[i]
-      ret += render(val[key], key, i)
-    }
-  }
-  return ret
-}
-
-function renderAttrs (obj: Object): string {
-  let res = ''
-  for (const key in obj) {
-    if (isSSRUnsafeAttr(key)) {
-      continue
-    }
-    res += renderAttr(key, obj[key])
-  }
-  return res
-}
-
-function renderDOMProps (obj: Object): string {
-  let res = ''
-  for (const key in obj) {
-    const attr = propsToAttrMap[key] || key.toLowerCase()
-    if (isRenderableAttr(attr)) {
-      res += renderAttr(attr, obj[key])
-    }
-  }
-  return res
-}
-
-function renderSSRClass (
-  staticClass: ?string,
-  dynamic: any
-): string {
-  const res = renderClass(staticClass, dynamic)
-  return res === '' ? res : ` class="${escape(res)}"`
-}
-
-function renderSSRStyle (
-  staticStyle: ?Object,
-  dynamic: any,
-  extra: ?Object
-): string {
-  const style = {}
-  if (staticStyle) extend(style, staticStyle)
-  if (dynamic) extend(style, normalizeStyleBinding(dynamic))
-  if (extra) extend(style, extra)
-  const res = genStyle(style)
-  return res === '' ? res : ` style=${JSON.stringify(escape(res))}`
-}
diff --git a/1.Vue/src/server/render-context.js b/1.Vue/src/server/render-context.js
deleted file mode 100644
index 3da91d0..0000000
--- a/1.Vue/src/server/render-context.js
+++ /dev/null
@@ -1,130 +0,0 @@
-/* @flow */
-
-import { isUndef } from 'shared/util'
-
-type RenderState = {
-  type: 'Element';
-  rendered: number;
-  total: number;
-  children: Array<VNode>;
-  endTag: string;
-} | {
-  type: 'Fragment';
-  rendered: number;
-  total: number;
-  children: Array<VNode>;
-} | {
-  type: 'Component';
-  prevActive: Component;
-} | {
-  type: 'ComponentWithCache';
-  buffer: Array<string>;
-  bufferIndex: number;
-  componentBuffer: Array<Set<Class<Component>>>;
-  key: string;
-};
-
-export class RenderContext {
-  userContext: ?Object;
-  activeInstance: Component;
-  renderStates: Array<RenderState>;
-  write: (text: string, next: Function) => void;
-  renderNode: (node: VNode, isRoot: boolean, context: RenderContext) => void;
-  next: () => void;
-  done: (err: ?Error) => void;
-
-  modules: Array<(node: VNode) => ?string>;
-  directives: Object;
-  isUnaryTag: (tag: string) => boolean;
-
-  cache: any;
-  get: ?(key: string, cb: Function) => void;
-  has: ?(key: string, cb: Function) => void;
-
-  constructor (options: Object) {
-    this.userContext = options.userContext
-    this.activeInstance = options.activeInstance
-    this.renderStates = []
-
-    this.write = options.write
-    this.done = options.done
-    this.renderNode = options.renderNode
-
-    this.isUnaryTag = options.isUnaryTag
-    this.modules = options.modules
-    this.directives = options.directives
-
-    const cache = options.cache
-    if (cache && (!cache.get || !cache.set)) {
-      throw new Error('renderer cache must implement at least get & set.')
-    }
-    this.cache = cache
-    this.get = cache && normalizeAsync(cache, 'get')
-    this.has = cache && normalizeAsync(cache, 'has')
-
-    this.next = this.next.bind(this)
-  }
-
-  next () {
-    // eslint-disable-next-line
-    while (true) {
-      const lastState = this.renderStates[this.renderStates.length - 1]
-      if (isUndef(lastState)) {
-        return this.done()
-      }
-      /* eslint-disable no-case-declarations */
-      switch (lastState.type) {
-        case 'Element':
-        case 'Fragment':
-          const { children, total } = lastState
-          const rendered = lastState.rendered++
-          if (rendered < total) {
-            return this.renderNode(children[rendered], false, this)
-          } else {
-            this.renderStates.pop()
-            if (lastState.type === 'Element') {
-              return this.write(lastState.endTag, this.next)
-            }
-          }
-          break
-        case 'Component':
-          this.renderStates.pop()
-          this.activeInstance = lastState.prevActive
-          break
-        case 'ComponentWithCache':
-          this.renderStates.pop()
-          const { buffer, bufferIndex, componentBuffer, key } = lastState
-          const result = {
-            html: buffer[bufferIndex],
-            components: componentBuffer[bufferIndex]
-          }
-          this.cache.set(key, result)
-          if (bufferIndex === 0) {
-            // this is a top-level cached component,
-            // exit caching mode.
-            this.write.caching = false
-          } else {
-            // parent component is also being cached,
-            // merge self into parent's result
-            buffer[bufferIndex - 1] += result.html
-            const prev = componentBuffer[bufferIndex - 1]
-            result.components.forEach(c => prev.add(c))
-          }
-          buffer.length = bufferIndex
-          componentBuffer.length = bufferIndex
-          break
-      }
-    }
-  }
-}
-
-function normalizeAsync (cache, method) {
-  const fn = cache[method]
-  if (isUndef(fn)) {
-    return
-  } else if (fn.length > 1) {
-    return (key, cb) => fn.call(cache, key, cb)
-  } else {
-    return (key, cb) => cb(fn.call(cache, key))
-  }
-}
diff --git a/1.Vue/src/server/render-stream.js b/1.Vue/src/server/render-stream.js
deleted file mode 100644
index bc358e2..0000000
--- a/1.Vue/src/server/render-stream.js
+++ /dev/null
@@ -1,95 +0,0 @@
-/* @flow */
-
-/**
- * Original RenderStream implementation by Sasha Aickin (@aickin)
- * Licensed under the Apache License, Version 2.0
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Modified by Evan You (@yyx990803)
- */
-
-const stream = require('stream')
-
-import { isTrue, isUndef } from 'shared/util'
-import { createWriteFunction } from './write'
-
-export default class RenderStream extends stream.Readable {
-  buffer: string;
-  render: (write: Function, done: Function) => void;
-  expectedSize: number;
-  write: Function;
-  next: Function;
-  end: Function;
-  done: boolean;
-
-  constructor (render: Function) {
-    super()
-    this.buffer = ''
-    this.render = render
-    this.expectedSize = 0
-
-    this.write = createWriteFunction((text, next) => {
-      const n = this.expectedSize
-      this.buffer += text
-      if (this.buffer.length >= n) {
-        this.next = next
-        this.pushBySize(n)
-        return true // we will decide when to call next
-      }
-      return false
-    }, err => {
-      this.emit('error', err)
-    })
-
-    this.end = () => {
-      this.emit('beforeEnd')
-      // the rendering is finished; we should push out the last of the buffer.
-      this.done = true
-      this.push(this.buffer)
-    }
-  }
-
-  pushBySize (n: number) {
-    const bufferToPush = this.buffer.substring(0, n)
-    this.buffer = this.buffer.substring(n)
-    this.push(bufferToPush)
-  }
-
-  tryRender () {
-    try {
-      this.render(this.write, this.end)
-    } catch (e) {
-      this.emit('error', e)
-    }
-  }
-
-  tryNext () {
-    try {
-      this.next()
-    } catch (e) {
-      this.emit('error', e)
-    }
-  }
-
-  _read (n: number) {
-    this.expectedSize = n
-    // it's possible that the last chunk added bumped the buffer up to > 2 * n,
-    // which means we will need to go through multiple read calls to drain it
-    // down to < n.
-    if (isTrue(this.done)) {
-      this.push(null)
-      return
-    }
-    if (this.buffer.length >= n) {
-      this.pushBySize(n)
-      return
-    }
-    if (isUndef(this.next)) {
-      // start the rendering chain.
-      this.tryRender()
-    } else {
-      // continue with the rendering.
-      this.tryNext()
-    }
-  }
-}
diff --git a/1.Vue/src/server/render.js b/1.Vue/src/server/render.js
deleted file mode 100644
index 05ba588..0000000
--- a/1.Vue/src/server/render.js
+++ /dev/null
@@ -1,437 +0,0 @@
-/* @flow */
-
-import { escape } from 'web/server/util'
-import { SSR_ATTR } from 'shared/constants'
-import { RenderContext } from './render-context'
-import { resolveAsset } from 'core/util/options'
-import { generateComponentTrace } from 'core/util/debug'
-import { ssrCompileToFunctions } from 'web/server/compiler'
-import { installSSRHelpers } from './optimizing-compiler/runtime-helpers'
-
-import { isDef, isUndef, isTrue } from 'shared/util'
-
-import {
-  createComponent,
-  createComponentInstanceForVnode
-} from 'core/vdom/create-component'
-
-let warned = Object.create(null)
-const warnOnce = msg => {
-  if (!warned[msg]) {
-    warned[msg] = true
-    // eslint-disable-next-line no-console
-    console.warn(`\n\u001b[31m${msg}\u001b[39m\n`)
-  }
-}
-
-const onCompilationError = (err, vm) => {
-  const trace = vm ? generateComponentTrace(vm) : ''
-  throw new Error(`\n\u001b[31m${err}${trace}\u001b[39m\n`)
-}
-
-const normalizeRender = vm => {
-  const { render, template, _scopeId } = vm.$options
-  if (isUndef(render)) {
-    if (template) {
-      const compiled = ssrCompileToFunctions(template, {
-        scopeId: _scopeId,
-        warn: onCompilationError
-      }, vm)
-
-      vm.$options.render = compiled.render
-      vm.$options.staticRenderFns = compiled.staticRenderFns
-    } else {
-      throw new Error(
-        `render function or template not defined in component: ${
-          vm.$options.name || vm.$options._componentTag || 'anonymous'
-        }`
-      )
-    }
-  }
-}
-
-function waitForServerPrefetch (vm, resolve, reject) {
-  let handlers = vm.$options.serverPrefetch
-  if (isDef(handlers)) {
-    if (!Array.isArray(handlers)) handlers = [handlers]
-    try {
-      const promises = []
-      for (let i = 0, j = handlers.length; i < j; i++) {
-        const result = handlers[i].call(vm, vm)
-        if (result && typeof result.then === 'function') {
-          promises.push(result)
-        }
-      }
-      Promise.all(promises).then(resolve).catch(reject)
-      return
-    } catch (e) {
-      reject(e)
-    }
-  }
-  resolve()
-}
-
-function renderNode (node, isRoot, context) {
-  if (node.isString) {
-    renderStringNode(node, context)
-  } else if (isDef(node.componentOptions)) {
-    renderComponent(node, isRoot, context)
-  } else if (isDef(node.tag)) {
-    renderElement(node, isRoot, context)
-  } else if (isTrue(node.isComment)) {
-    if (isDef(node.asyncFactory)) {
-      // async component
-      renderAsyncComponent(node, isRoot, context)
-    } else {
-      context.write(`<!--${node.text}-->`, context.next)
-    }
-  } else {
-    context.write(
-      node.raw ? node.text : escape(String(node.text)),
-      context.next
-    )
-  }
-}
-
-function registerComponentForCache (options, write) {
-  // exposed by vue-loader, need to call this if cache hit because
-  // component lifecycle hooks will not be called.
-  const register = options._ssrRegister
-  if (write.caching && isDef(register)) {
-    write.componentBuffer[write.componentBuffer.length - 1].add(register)
-  }
-  return register
-}
-
-function renderComponent (node, isRoot, context) {
-  const { write, next, userContext } = context
-
-  // check cache hit
-  const Ctor = node.componentOptions.Ctor
-  const getKey = Ctor.options.serverCacheKey
-  const name = Ctor.options.name
-  const cache = context.cache
-  const registerComponent = registerComponentForCache(Ctor.options, write)
-
-  if (isDef(getKey) && isDef(cache) && isDef(name)) {
-    const rawKey = getKey(node.componentOptions.propsData)
-    if (rawKey === false) {
-      renderComponentInner(node, isRoot, context)
-      return
-    }
-    const key = name + '::' + rawKey
-    const { has, get } = context
-    if (isDef(has)) {
-      has(key, hit => {
-        if (hit === true && isDef(get)) {
-          get(key, res => {
-            if (isDef(registerComponent)) {
-              registerComponent(userContext)
-            }
-            res.components.forEach(register => register(userContext))
-            write(res.html, next)
-          })
-        } else {
-          renderComponentWithCache(node, isRoot, key, context)
-        }
-      })
-    } else if (isDef(get)) {
-      get(key, res => {
-        if (isDef(res)) {
-          if (isDef(registerComponent)) {
-            registerComponent(userContext)
-          }
-          res.components.forEach(register => register(userContext))
-          write(res.html, next)
-        } else {
-          renderComponentWithCache(node, isRoot, key, context)
-        }
-      })
-    }
-  } else {
-    if (isDef(getKey) && isUndef(cache)) {
-      warnOnce(
-        `[vue-server-renderer] Component ${
-          Ctor.options.name || '(anonymous)'
-        } implemented serverCacheKey, ` +
-        'but no cache was provided to the renderer.'
-      )
-    }
-    if (isDef(getKey) && isUndef(name)) {
-      warnOnce(
-        `[vue-server-renderer] Components that implement "serverCacheKey" ` +
-        `must also define a unique "name" option.`
-      )
-    }
-    renderComponentInner(node, isRoot, context)
-  }
-}
-
-function renderComponentWithCache (node, isRoot, key, context) {
-  const write = context.write
-  write.caching = true
-  const buffer = write.cacheBuffer
-  const bufferIndex = buffer.push('') - 1
-  const componentBuffer = write.componentBuffer
-  componentBuffer.push(new Set())
-  context.renderStates.push({
-    type: 'ComponentWithCache',
-    key,
-    buffer,
-    bufferIndex,
-    componentBuffer
-  })
-  renderComponentInner(node, isRoot, context)
-}
-
-function renderComponentInner (node, isRoot, context) {
-  const prevActive = context.activeInstance
-  // expose userContext on vnode
-  node.ssrContext = context.userContext
-  const child = context.activeInstance = createComponentInstanceForVnode(
-    node,
-    context.activeInstance
-  )
-  normalizeRender(child)
-
-  const resolve = () => {
-    const childNode = child._render()
-    childNode.parent = node
-    context.renderStates.push({
-      type: 'Component',
-      prevActive
-    })
-    renderNode(childNode, isRoot, context)
-  }
-
-  const reject = context.done
-
-  waitForServerPrefetch(child, resolve, reject)
-}
-
-function renderAsyncComponent (node, isRoot, context) {
-  const factory = node.asyncFactory
-
-  const resolve = comp => {
-    if (comp.__esModule && comp.default) {
-      comp = comp.default
-    }
-    const { data, children, tag } = node.asyncMeta
-    const nodeContext = node.asyncMeta.context
-    const resolvedNode: any = createComponent(
-      comp,
-      data,
-      nodeContext,
-      children,
-      tag
-    )
-    if (resolvedNode) {
-      if (resolvedNode.componentOptions) {
-        // normal component
-        renderComponent(resolvedNode, isRoot, context)
-      } else if (!Array.isArray(resolvedNode)) {
-        // single return node from functional component
-        renderNode(resolvedNode, isRoot, context)
-      } else {
-        // multiple return nodes from functional component
-        context.renderStates.push({
-          type: 'Fragment',
-          children: resolvedNode,
-          rendered: 0,
-          total: resolvedNode.length
-        })
-        context.next()
-      }
-    } else {
-      // invalid component, but this does not throw on the client
-      // so render empty comment node
-      context.write(`<!---->`, context.next)
-    }
-  }
-
-  if (factory.resolved) {
-    resolve(factory.resolved)
-    return
-  }
-
-  const reject = context.done
-  let res
-  try {
-    res = factory(resolve, reject)
-  } catch (e) {
-    reject(e)
-  }
-  if (res) {
-    if (typeof res.then === 'function') {
-      res.then(resolve, reject).catch(reject)
-    } else {
-      // new syntax in 2.3
-      const comp = res.component
-      if (comp && typeof comp.then === 'function') {
-        comp.then(resolve, reject).catch(reject)
-      }
-    }
-  }
-}
-
-function renderStringNode (el, context) {
-  const { write, next } = context
-  if (isUndef(el.children) || el.children.length === 0) {
-    write(el.open + (el.close || ''), next)
-  } else {
-    const children: Array<VNode> = el.children
-    context.renderStates.push({
-      type: 'Element',
-      children,
-      rendered: 0,
-      total: children.length,
-      endTag: el.close
-    })
-    write(el.open, next)
-  }
-}
-
-function renderElement (el, isRoot, context) {
-  const { write, next } = context
-
-  if (isTrue(isRoot)) {
-    if (!el.data) el.data = {}
-    if (!el.data.attrs) el.data.attrs = {}
-    el.data.attrs[SSR_ATTR] = 'true'
-  }
-
-  if (el.fnOptions) {
-    registerComponentForCache(el.fnOptions, write)
-  }
-
-  const startTag = renderStartingTag(el, context)
-  const endTag = `</${el.tag}>`
-  if (context.isUnaryTag(el.tag)) {
-    write(startTag, next)
-  } else if (isUndef(el.children) || el.children.length === 0) {
-    write(startTag + endTag, next)
-  } else {
-    const children: Array<VNode> = el.children
-    context.renderStates.push({
-      type: 'Element',
-      children,
-      rendered: 0,
-      total: children.length,
-      endTag
-    })
-    write(startTag, next)
-  }
-}
-
-function hasAncestorData (node: VNode) {
-  const parentNode = node.parent
-  return isDef(parentNode) && (isDef(parentNode.data) || hasAncestorData(parentNode))
-}
-
-function getVShowDirectiveInfo (node: VNode): ?VNodeDirective {
-  let dir: VNodeDirective
-  let tmp
-
-  while (isDef(node)) {
-    if (node.data && node.data.directives) {
-      tmp = node.data.directives.find(dir => dir.name === 'show')
-      if (tmp) {
-        dir = tmp
-      }
-    }
-    node = node.parent
-  }
-  return dir
-}
-
-function renderStartingTag (node: VNode, context) {
-  let markup = `<${node.tag}`
-  const { directives, modules } = context
-
-  // construct synthetic data for module processing
-  // because modules like style also produce code by parent VNode data
-  if (isUndef(node.data) && hasAncestorData(node)) {
-    node.data = {}
-  }
-  if (isDef(node.data)) {
-    // check directives
-    const dirs = node.data.directives
-    if (dirs) {
-      for (let i = 0; i < dirs.length; i++) {
-        const name = dirs[i].name
-        if (name !== 'show') {
-          const dirRenderer = resolveAsset(context, 'directives', name)
-          if (dirRenderer) {
-            // directives mutate the node's data
-            // which then gets rendered by modules
-            dirRenderer(node, dirs[i])
-          }
-        }
-      }
-    }
-
-    // v-show directive needs to be merged from parent to child
-    const vshowDirectiveInfo = getVShowDirectiveInfo(node)
-    if (vshowDirectiveInfo) {
-      directives.show(node, vshowDirectiveInfo)
-    }
-
-    // apply other modules
-    for (let i = 0; i < modules.length; i++) {
-      const res = modules[i](node)
-      if (res) {
-        markup += res
-      }
-    }
-  }
-  // attach scoped CSS ID
-  let scopeId
-  const activeInstance = context.activeInstance
-  if (isDef(activeInstance) &&
-    activeInstance !== node.context &&
-    isDef(scopeId = activeInstance.$options._scopeId)
-  ) {
-    markup += ` ${(scopeId: any)}`
-  }
-  if (isDef(node.fnScopeId)) {
-    markup += ` ${node.fnScopeId}`
-  } else {
-    while (isDef(node)) {
-      if (isDef(scopeId = node.context.$options._scopeId)) {
-        markup += ` ${scopeId}`
-      }
-      node = node.parent
-    }
-  }
-  return markup + '>'
-}
-
-export function createRenderFunction (
-  modules: Array<(node: VNode) => ?string>,
-  directives: Object,
-  isUnaryTag: Function,
-  cache: any
-) {
-  return function render (
-    component: Component,
-    write: (text: string, next: Function) => void,
-    userContext: ?Object,
-    done: Function
-  ) {
-    warned = Object.create(null)
-    const context = new RenderContext({
-      activeInstance: component,
-      userContext,
-      write, done, renderNode,
-      isUnaryTag, modules, directives,
-      cache
-    })
-    installSSRHelpers(component)
-    normalizeRender(component)
-
-    const resolve = () => {
-      renderNode(component._render(), true, context)
-    }
-    waitForServerPrefetch(component, resolve, done)
-  }
-}
diff --git a/1.Vue/src/server/template-renderer/create-async-file-mapper.js b/1.Vue/src/server/template-renderer/create-async-file-mapper.js
deleted file mode 100644
index c989e33..0000000
--- a/1.Vue/src/server/template-renderer/create-async-file-mapper.js
+++ /dev/null
@@ -1,53 +0,0 @@
-/* @flow */
-
-/**
- * Creates a mapper that maps components used during a server-side render
- * to async chunk files in the client-side build, so that we can inline them
- * directly in the rendered HTML to avoid waterfall requests.
- */
-
-import type { ClientManifest } from './index'
-
-export type AsyncFileMapper = (files: Array<string>) => Array<string>;
-
-export function createMapper (
-  clientManifest: ClientManifest
-): AsyncFileMapper {
-  const map = createMap(clientManifest)
-  // map server-side moduleIds to client-side files
-  return function mapper (moduleIds: Array<string>): Array<string> {
-    const res = new Set()
-    for (let i = 0; i < moduleIds.length; i++) {
-      const mapped = map.get(moduleIds[i])
-      if (mapped) {
-        for (let j = 0; j < mapped.length; j++) {
-          res.add(mapped[j])
-        }
-      }
-    }
-    return Array.from(res)
-  }
-}
-
-function createMap (clientManifest) {
-  const map = new Map()
-  Object.keys(clientManifest.modules).forEach(id => {
-    map.set(id, mapIdToFile(id, clientManifest))
-  })
-  return map
-}
-
-function mapIdToFile (id, clientManifest) {
-  const files = []
-  const fileIndices = clientManifest.modules[id]
-  if (fileIndices) {
-    fileIndices.forEach(index => {
-      const file = clientManifest.all[index]
-      // only include async files or non-js, non-css assets
-      if (clientManifest.async.indexOf(file) > -1 || !(/\.(js|css)($|\?)/.test(file))) {
-        files.push(file)
-      }
-    })
-  }
-  return files
-}
diff --git a/1.Vue/src/server/template-renderer/index.js b/1.Vue/src/server/template-renderer/index.js
deleted file mode 100644
index c8927b2..0000000
--- a/1.Vue/src/server/template-renderer/index.js
+++ /dev/null
@@ -1,277 +0,0 @@
-/* @flow */
-
-const path = require('path')
-const serialize = require('serialize-javascript')
-
-import { isJS, isCSS } from '../util'
-import TemplateStream from './template-stream'
-import { parseTemplate } from './parse-template'
-import { createMapper } from './create-async-file-mapper'
-import type { ParsedTemplate } from './parse-template'
-import type { AsyncFileMapper } from './create-async-file-mapper'
-
-type TemplateRendererOptions = {
-  template?: string | (content: string, context: any) => string;
-  inject?: boolean;
-  clientManifest?: ClientManifest;
-  shouldPreload?: (file: string, type: string) => boolean;
-  shouldPrefetch?: (file: string, type: string) => boolean;
-  serializer?: Function;
-};
-
-export type ClientManifest = {
-  publicPath: string;
-  all: Array<string>;
-  initial: Array<string>;
-  async: Array<string>;
-  modules: {
-    [id: string]: Array<number>;
-  },
-  hasNoCssVersion?: {
-    [file: string]: boolean;
-  }
-};
-
-type Resource = {
-  file: string;
-  extension: string;
-  fileWithoutQuery: string;
-  asType: string;
-};
-
-export default class TemplateRenderer {
-  options: TemplateRendererOptions;
-  inject: boolean;
-  parsedTemplate: ParsedTemplate | Function | null;
-  publicPath: string;
-  clientManifest: ClientManifest;
-  preloadFiles: Array<Resource>;
-  prefetchFiles: Array<Resource>;
-  mapFiles: AsyncFileMapper;
-  serialize: Function;
-
-  constructor (options: TemplateRendererOptions) {
-    this.options = options
-    this.inject = options.inject !== false
-    // if no template option is provided, the renderer is created
-    // as a utility object for rendering assets like preload links and scripts.
-    
-    const { template } = options
-    this.parsedTemplate = template
-      ? typeof template === 'string'
-        ? parseTemplate(template)
-        : template
-      : null
-
-    // function used to serialize initial state JSON
-    this.serialize = options.serializer || (state => {
-      return serialize(state, { isJSON: true })
-    })
-
-    // extra functionality with client manifest
-    if (options.clientManifest) {
-      const clientManifest = this.clientManifest = options.clientManifest
-      // ensure publicPath ends with /
-      this.publicPath = clientManifest.publicPath === ''
-        ? ''
-        : clientManifest.publicPath.replace(/([^\/])$/, '$1/')
-      // preload/prefetch directives
-      this.preloadFiles = (clientManifest.initial || []).map(normalizeFile)
-      this.prefetchFiles = (clientManifest.async || []).map(normalizeFile)
-      // initial async chunk mapping
-      this.mapFiles = createMapper(clientManifest)
-    }
-  }
-
-  bindRenderFns (context: Object) {
-    const renderer: any = this
-    ;['ResourceHints', 'State', 'Scripts', 'Styles'].forEach(type => {
-      context[`render${type}`] = renderer[`render${type}`].bind(renderer, context)
-    })
-    // also expose getPreloadFiles, useful for HTTP/2 push
-    context.getPreloadFiles = renderer.getPreloadFiles.bind(renderer, context)
-  }
-
-  // render synchronously given rendered app content and render context
-  render (content: string, context: ?Object): string | Promise<string> {
-    const template = this.parsedTemplate
-    if (!template) {
-      throw new Error('render cannot be called without a template.')
-    }
-    context = context || {}
-
-    if (typeof template === 'function') {
-      return template(content, context)
-    }
-
-    if (this.inject) {
-      return (
-        template.head(context) +
-        (context.head || '') +
-        this.renderResourceHints(context) +
-        this.renderStyles(context) +
-        template.neck(context) +
-        content +
-        this.renderState(context) +
-        this.renderScripts(context) +
-        template.tail(context)
-      )
-    } else {
-      return (
-        template.head(context) +
-        template.neck(context) +
-        content +
-        template.tail(context)
-      )
-    }
-  }
-
-  renderStyles (context: Object): string {
-    const initial = this.preloadFiles || []
-    const async = this.getUsedAsyncFiles(context) || []
-    const cssFiles = initial.concat(async).filter(({ file }) => isCSS(file))
-    return (
-      // render links for css files
-      (cssFiles.length
-        ? cssFiles.map(({ file }) => `<link rel="stylesheet" href="${this.publicPath}${file}">`).join('')
-        : '') +
-      // context.styles is a getter exposed by vue-style-loader which contains
-      // the inline component styles collected during SSR
-      (context.styles || '')
-    )
-  }
-
-  renderResourceHints (context: Object): string {
-    return this.renderPreloadLinks(context) + this.renderPrefetchLinks(context)
-  }
-
-  getPreloadFiles (context: Object): Array<Resource> {
-    const usedAsyncFiles = this.getUsedAsyncFiles(context)
-    if (this.preloadFiles || usedAsyncFiles) {
-      return (this.preloadFiles || []).concat(usedAsyncFiles || [])
-    } else {
-      return []
-    }
-  }
-
-  renderPreloadLinks (context: Object): string {
-    const files = this.getPreloadFiles(context)
-    const shouldPreload = this.options.shouldPreload
-    if (files.length) {
-      return files.map(({ file, extension, fileWithoutQuery, asType }) => {
-        let extra = ''
-        // by default, we only preload scripts or css
-        if (!shouldPreload && asType !== 'script' && asType !== 'style') {
-          return ''
-        }
-        // user wants to explicitly control what to preload
-        if (shouldPreload && !shouldPreload(fileWithoutQuery, asType)) {
-          return ''
-        }
-        if (asType === 'font') {
-          extra = ` type="font/${extension}" crossorigin`
-        }
-        return `<link rel="preload" href="${
-          this.publicPath}${file
-        }"${
-          asType !== '' ? ` as="${asType}"` : ''
-        }${
-          extra
-        }>`
-      }).join('')
-    } else {
-      return ''
-    }
-  }
-
-  renderPrefetchLinks (context: Object): string {
-    const shouldPrefetch = this.options.shouldPrefetch
-    if (this.prefetchFiles) {
-      const usedAsyncFiles = this.getUsedAsyncFiles(context)
-      const alreadyRendered = file => {
-        return usedAsyncFiles && usedAsyncFiles.some(f => f.file === file)
-      }
-      return this.prefetchFiles.map(({ file, fileWithoutQuery, asType }) => {
-        if (shouldPrefetch && !shouldPrefetch(fileWithoutQuery, asType)) {
-          return ''
-        }
-        if (alreadyRendered(file)) {
-          return ''
-        }
-        return `<link rel="prefetch" href="${this.publicPath}${file}">`
-      }).join('')
-    } else {
-      return ''
-    }
-  }
-
-  renderState (context: Object, options?: Object): string {
-    const {
-      contextKey = 'state',
-      windowKey = '__INITIAL_STATE__'
-    } = options || {}
-    const state = this.serialize(context[contextKey])
-    const autoRemove = process.env.NODE_ENV === 'production'
-      ? ';(function(){var s;(s=document.currentScript||document.scripts[document.scripts.length-1]).parentNode.removeChild(s);}());'
-      : ''
-    const nonceAttr = context.nonce ? ` nonce="${context.nonce}"` : ''
-    return context[contextKey]
-      ? `<script${nonceAttr}>window.${windowKey}=${state}${autoRemove}</script>`
-      : ''
-  }
-
-  renderScripts (context: Object): string {
-    if (this.clientManifest) {
-      const initial = this.preloadFiles.filter(({ file }) => isJS(file))
-      const async = (this.getUsedAsyncFiles(context) || []).filter(({ file }) => isJS(file))
-      const needed = [initial[0]].concat(async, initial.slice(1))
-      return needed.map(({ file }) => {
-        return `<script src="${this.publicPath}${file}" defer></script>`
-      }).join('')
-    } else {
-      return ''
-    }
-  }
-
-  getUsedAsyncFiles (context: Object): ?Array<Resource> {
-    if (!context._mappedFiles && context._registeredComponents && this.mapFiles) {
-      const registered = Array.from(context._registeredComponents)
-      context._mappedFiles = this.mapFiles(registered).map(normalizeFile)
-    }
-    return context._mappedFiles
-  }
-
-  // create a transform stream
-  createStream (context: ?Object): TemplateStream {
-    if (!this.parsedTemplate) {
-      throw new Error('createStream cannot be called without a template.')
-    }
-    return new TemplateStream(this, this.parsedTemplate, context || {})
-  }
-}
-
-function normalizeFile (file: string): Resource {
-  const withoutQuery = file.replace(/\?.*/, '')
-  const extension = path.extname(withoutQuery).slice(1)
-  return {
-    file,
-    extension,
-    fileWithoutQuery: withoutQuery,
-    asType: getPreloadType(extension)
-  }
-}
-
-function getPreloadType (ext: string): string {
-  if (ext === 'js') {
-    return 'script'
-  } else if (ext === 'css') {
-    return 'style'
-  } else if (/jpe?g|png|svg|gif|webp|ico/.test(ext)) {
-    return 'image'
-  } else if (/woff2?|ttf|otf|eot/.test(ext)) {
-    return 'font'
-  } else {
-    // not exhausting all possibilities here, but above covers common cases
-    return ''
-  }
-}
diff --git a/1.Vue/src/server/template-renderer/parse-template.js b/1.Vue/src/server/template-renderer/parse-template.js
deleted file mode 100644
index 1ccfe89..0000000
--- a/1.Vue/src/server/template-renderer/parse-template.js
+++ /dev/null
@@ -1,42 +0,0 @@
-/* @flow */
-
-const compile = require('lodash.template')
-const compileOptions = {
-  escape: /{{([^{][\s\S]+?[^}])}}/g,
-  interpolate: /{{{([\s\S]+?)}}}/g
-}
-
-export type ParsedTemplate = {
-  head: (data: any) => string;
-  neck: (data: any) => string;
-  tail: (data: any) => string;
-};
-
-export function parseTemplate (
-  template: string,
-  contentPlaceholder?: string = '<!--vue-ssr-outlet-->'
-): ParsedTemplate {
-  if (typeof template === 'object') {
-    return template
-  }
-
-  let i = template.indexOf('</head>')
-  const j = template.indexOf(contentPlaceholder)
-
-  if (j < 0) {
-    throw new Error(`Content placeholder not found in template.`)
-  }
-
-  if (i < 0) {
-    i = template.indexOf('<body>')
-    if (i < 0) {
-      i = j
-    }
-  }
-
-  return {
-    head: compile(template.slice(0, i), compileOptions),
-    neck: compile(template.slice(i, j), compileOptions),
-    tail: compile(template.slice(j + contentPlaceholder.length), compileOptions)
-  }
-}
diff --git a/1.Vue/src/server/template-renderer/template-stream.js b/1.Vue/src/server/template-renderer/template-stream.js
deleted file mode 100644
index ed4db78..0000000
--- a/1.Vue/src/server/template-renderer/template-stream.js
+++ /dev/null
@@ -1,82 +0,0 @@
-/* @flow */
-
-const Transform = require('stream').Transform
-import type TemplateRenderer from './index'
-import type { ParsedTemplate } from './parse-template'
-
-export default class TemplateStream extends Transform {
-  started: boolean;
-  renderer: TemplateRenderer;
-  template: ParsedTemplate;
-  context: Object;
-  inject: boolean;
-
-  constructor (
-    renderer: TemplateRenderer,
-    template: ParsedTemplate,
-    context: Object
-  ) {
-    super()
-    this.started = false
-    this.renderer = renderer
-    this.template = template
-    this.context = context || {}
-    this.inject = renderer.inject
-  }
-
-  _transform (data: Buffer | string, encoding: string, done: Function) {
-    if (!this.started) {
-      this.emit('beforeStart')
-      this.start()
-    }
-    this.push(data)
-    done()
-  }
-
-  start () {
-    this.started = true
-    this.push(this.template.head(this.context))
-
-    if (this.inject) {
-      // inline server-rendered head meta information
-      if (this.context.head) {
-        this.push(this.context.head)
-      }
-
-      // inline preload/prefetch directives for initial/async chunks
-      const links = this.renderer.renderResourceHints(this.context)
-      if (links) {
-        this.push(links)
-      }
-
-      // CSS files and inline server-rendered CSS collected by vue-style-loader
-      const styles = this.renderer.renderStyles(this.context)
-      if (styles) {
-        this.push(styles)
-      }
-    }
-
-    this.push(this.template.neck(this.context))
-  }
-
-  _flush (done: Function) {
-    this.emit('beforeEnd')
-
-    if (this.inject) {
-      // inline initial store state
-      const state = this.renderer.renderState(this.context)
-      if (state) {
-        this.push(state)
-      }
-
-      // embed scripts needed
-      const scripts = this.renderer.renderScripts(this.context)
-      if (scripts) {
-        this.push(scripts)
-      }
-    }
-
-    this.push(this.template.tail(this.context))
-    done()
-  }
-}
diff --git a/1.Vue/src/server/util.js b/1.Vue/src/server/util.js
deleted file mode 100644
index 908f8c9..0000000
--- a/1.Vue/src/server/util.js
+++ /dev/null
@@ -1,18 +0,0 @@
-/* @flow */
-
-export const isJS = (file: string): boolean => /\.js(\?[^.]+)?$/.test(file)
-
-export const isCSS = (file: string): boolean => /\.css(\?[^.]+)?$/.test(file)
-
-export function createPromiseCallback () {
-  let resolve, reject
-  const promise: Promise<string> = new Promise((_resolve, _reject) => {
-    resolve = _resolve
-    reject = _reject
-  })
-  const cb = (err: Error, res?: string) => {
-    if (err) return reject(err)
-    resolve(res || '')
-  }
-  return { promise, cb }
-}
diff --git a/1.Vue/src/server/webpack-plugin/client.js b/1.Vue/src/server/webpack-plugin/client.js
deleted file mode 100644
index ae2a249..0000000
--- a/1.Vue/src/server/webpack-plugin/client.js
+++ /dev/null
@@ -1,65 +0,0 @@
-const hash = require('hash-sum')
-const uniq = require('lodash.uniq')
-import { isJS, isCSS, onEmit } from './util'
-
-export default class VueSSRClientPlugin {
-  constructor (options = {}) {
-    this.options = Object.assign({
-      filename: 'vue-ssr-client-manifest.json'
-    }, options)
-  }
-
-  apply (compiler) {
-    onEmit(compiler, 'vue-client-plugin', (compilation, cb) => {
-      const stats = compilation.getStats().toJson()
-
-      const allFiles = uniq(stats.assets
-        .map(a => a.name))
-
-      const initialFiles = uniq(Object.keys(stats.entrypoints)
-        .map(name => stats.entrypoints[name].assets)
-        .reduce((assets, all) => all.concat(assets), [])
-        .filter((file) => isJS(file) || isCSS(file)))
-
-      const asyncFiles = allFiles
-        .filter((file) => isJS(file) || isCSS(file))
-        .filter(file => initialFiles.indexOf(file) < 0)
-
-      const manifest = {
-        publicPath: stats.publicPath,
-        all: allFiles,
-        initial: initialFiles,
-        async: asyncFiles,
-        modules: { /* [identifier: string]: Array<index: number> */ }
-      }
-
-      const assetModules = stats.modules.filter(m => m.assets.length)
-      const fileToIndex = file => manifest.all.indexOf(file)
-      stats.modules.forEach(m => {
-        // ignore modules duplicated in multiple chunks
-        if (m.chunks.length === 1) {
-          const cid = m.chunks[0]
-          const chunk = stats.chunks.find(c => c.id === cid)
-          if (!chunk || !chunk.files) {
-            return
-          }
-          const id = m.identifier.replace(/\s\w+$/, '') // remove appended hash
-          const files = manifest.modules[hash(id)] = chunk.files.map(fileToIndex)
-          // find all asset modules associated with the same chunk
-          assetModules.forEach(m => {
-            if (m.chunks.some(id => id === cid)) {
-              files.push.apply(files, m.assets.map(fileToIndex))
-            }
-          })
-        }
-      })
-
-      const json = JSON.stringify(manifest, null, 2)
-      compilation.assets[this.options.filename] = {
-        source: () => json,
-        size: () => json.length
-      }
-      cb()
-    })
-  }
-}
diff --git a/1.Vue/src/server/webpack-plugin/server.js b/1.Vue/src/server/webpack-plugin/server.js
deleted file mode 100644
index 305b4ba..0000000
--- a/1.Vue/src/server/webpack-plugin/server.js
+++ /dev/null
@@ -1,66 +0,0 @@
-import { validate, isJS, onEmit } from './util'
-
-export default class VueSSRServerPlugin {
-  constructor (options = {}) {
-    this.options = Object.assign({
-      filename: 'vue-ssr-server-bundle.json'
-    }, options)
-  }
-
-  apply (compiler) {
-    validate(compiler)
-
-    onEmit(compiler, 'vue-server-plugin', (compilation, cb) => {
-      const stats = compilation.getStats().toJson()
-      const entryName = Object.keys(stats.entrypoints)[0]
-      const entryInfo = stats.entrypoints[entryName]
-
-      if (!entryInfo) {
-        // #5553
-        return cb()
-      }
-
-      const entryAssets = entryInfo.assets.filter(isJS)
-
-      if (entryAssets.length > 1) {
-        throw new Error(
-          `Server-side bundle should have one single entry file. ` +
-          `Avoid using CommonsChunkPlugin in the server config.`
-        )
-      }
-
-      const entry = entryAssets[0]
-      if (!entry || typeof entry !== 'string') {
-        throw new Error(
-          `Entry "${entryName}" not found. Did you specify the correct entry option?`
-        )
-      }
-
-      const bundle = {
-        entry,
-        files: {},
-        maps: {}
-      }
-
-      stats.assets.forEach(asset => {
-        if (isJS(asset.name)) {
-          bundle.files[asset.name] = compilation.assets[asset.name].source()
-        } else if (asset.name.match(/\.js\.map$/)) {
-          bundle.maps[asset.name.replace(/\.map$/, '')] = JSON.parse(compilation.assets[asset.name].source())
-        }
-        // do not emit anything else for server
-        delete compilation.assets[asset.name]
-      })
-
-      const json = JSON.stringify(bundle, null, 2)
-      const filename = this.options.filename
-
-      compilation.assets[filename] = {
-        source: () => json,
-        size: () => json.length
-      }
-
-      cb()
-    })
-  }
-}
diff --git a/1.Vue/src/server/webpack-plugin/util.js b/1.Vue/src/server/webpack-plugin/util.js
deleted file mode 100644
index 94a204a..0000000
--- a/1.Vue/src/server/webpack-plugin/util.js
+++ /dev/null
@@ -1,34 +0,0 @@
-const { red, yellow } = require('chalk')
-
-const prefix = `[vue-server-renderer-webpack-plugin]`
-const warn = exports.warn = msg => console.error(red(`${prefix} ${msg}\n`))
-const tip = exports.tip = msg => console.log(yellow(`${prefix} ${msg}\n`))
-
-export const validate = compiler => {
-  if (compiler.options.target !== 'node') {
-    warn('webpack config `target` should be "node".')
-  }
-
-  if (compiler.options.output && compiler.options.output.libraryTarget !== 'commonjs2') {
-    warn('webpack config `output.libraryTarget` should be "commonjs2".')
-  }
-
-  if (!compiler.options.externals) {
-    tip(
-      'It is recommended to externalize dependencies in the server build for ' +
-      'better build performance.'
-    )
-  }
-}
-
-export const onEmit = (compiler, name, hook) => {
-  if (compiler.hooks) {
-    // Webpack >= 4.0.0
-    compiler.hooks.emit.tapAsync(name, hook)
-  } else {
-    // Webpack < 4.0.0
-    compiler.plugin('emit', hook)
-  }
-}
-
-export { isJS, isCSS } from '../util'
diff --git a/1.Vue/src/server/write.js b/1.Vue/src/server/write.js
deleted file mode 100644
index 27a5e8a..0000000
--- a/1.Vue/src/server/write.js
+++ /dev/null
@@ -1,50 +0,0 @@
-/* @flow */
-
-const MAX_STACK_DEPTH = 800
-const noop = _ => _
-
-const defer = typeof process !== 'undefined' && process.nextTick
-  ? process.nextTick
-  : typeof Promise !== 'undefined'
-    ? fn => Promise.resolve().then(fn)
-    : typeof setTimeout !== 'undefined'
-      ? setTimeout
-      : noop
-
-if (defer === noop) {
-  throw new Error(
-    'Your JavaScript runtime does not support any asynchronous primitives ' +
-    'that are required by vue-server-renderer. Please use a polyfill for ' +
-    'either Promise or setTimeout.'
-  )
-}
-
-export function createWriteFunction (
-  write: (text: string, next: Function) => boolean,
-  onError: Function
-): Function {
-  let stackDepth = 0
-  const cachedWrite = (text, next) => {
-    if (text && cachedWrite.caching) {
-      cachedWrite.cacheBuffer[cachedWrite.cacheBuffer.length - 1] += text
-    }
-    const waitForNext = write(text, next)
-    if (waitForNext !== true) {
-      if (stackDepth >= MAX_STACK_DEPTH) {
-        defer(() => {
-          try { next() } catch (e) {
-            onError(e)
-          }
-        })
-      } else {
-        stackDepth++
-        next()
-        stackDepth--
-      }
-    }
-  }
-  cachedWrite.caching = false
-  cachedWrite.cacheBuffer = []
-  cachedWrite.componentBuffer = []
-  return cachedWrite
-}
diff --git a/1.Vue/src/sfc/parser.js b/1.Vue/src/sfc/parser.js
deleted file mode 100644
index 59c5fc3..0000000
--- a/1.Vue/src/sfc/parser.js
+++ /dev/null
@@ -1,134 +0,0 @@
-/* @flow */
-
-import deindent from 'de-indent'
-import { parseHTML } from 'compiler/parser/html-parser'
-import { makeMap } from 'shared/util'
-
-const splitRE = /\r?\n/g
-const replaceRE = /./g
-const isSpecialTag = makeMap('script,style,template', true)
-
-/**
- * Parse a single-file component (*.vue) file into an SFC Descriptor Object.
- */
-export function parseComponent (
-  content: string,
-  options?: Object = {}
-): SFCDescriptor {
-  const sfc: SFCDescriptor = {
-    template: null,
-    script: null,
-    styles: [],
-    customBlocks: [],
-    errors: []
-  }
-  let depth = 0
-  let currentBlock: ?SFCBlock = null
-
-  let warn = msg => {
-    sfc.errors.push(msg)
-  }
-
-  if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
-    warn = (msg, range) => {
-      const data: WarningMessage = { msg }
-      if (range.start != null) {
-        data.start = range.start
-      }
-      if (range.end != null) {
-        data.end = range.end
-      }
-      sfc.errors.push(data)
-    }
-  }
-
-  function start (
-    tag: string,
-    attrs: Array<ASTAttr>,
-    unary: boolean,
-    start: number,
-    end: number
-  ) {
-    if (depth === 0) {
-      currentBlock = {
-        type: tag,
-        content: '',
-        start: end,
-        attrs: attrs.reduce((cumulated, { name, value }) => {
-          cumulated[name] = value || true
-          return cumulated
-        }, {})
-      }
-      if (isSpecialTag(tag)) {
-        checkAttrs(currentBlock, attrs)
-        if (tag === 'style') {
-          sfc.styles.push(currentBlock)
-        } else {
-          sfc[tag] = currentBlock
-        }
-      } else { // custom blocks
-        sfc.customBlocks.push(currentBlock)
-      }
-    }
-    if (!unary) {
-      depth++
-    }
-  }
-
-  function checkAttrs (block: SFCBlock, attrs: Array<ASTAttr>) {
-    for (let i = 0; i < attrs.length; i++) {
-      const attr = attrs[i]
-      if (attr.name === 'lang') {
-        block.lang = attr.value
-      }
-      if (attr.name === 'scoped') {
-        block.scoped = true
-      }
-      if (attr.name === 'module') {
-        block.module = attr.value || true
-      }
-      if (attr.name === 'src') {
-        block.src = attr.value
-      }
-    }
-  }
-
-  function end (tag: string, start: number) {
-    if (depth === 1 && currentBlock) {
-      currentBlock.end = start
-      let text = content.slice(currentBlock.start, currentBlock.end)
-      if (options.deindent !== false) {
-        text = deindent(text)
-      }
-      // pad content so that linters and pre-processors can output correct
-      // line numbers in errors and warnings
-      if (currentBlock.type !== 'template' && options.pad) {
-        text = padContent(currentBlock, options.pad) + text
-      }
-      currentBlock.content = text
-      currentBlock = null
-    }
-    depth--
-  }
-
-  function padContent (block: SFCBlock, pad: true | "line" | "space") {
-    if (pad === 'space') {
-      return content.slice(0, block.start).replace(replaceRE, ' ')
-    } else {
-      const offset = content.slice(0, block.start).split(splitRE).length
-      const padChar = block.type === 'script' && !block.lang
-        ? '//\n'
-        : '\n'
-      return Array(offset).join(padChar)
-    }
-  }
-
-  parseHTML(content, {
-    warn,
-    start,
-    end,
-    outputSourceRange: options.outputSourceRange
-  })
-
-  return sfc
-}
diff --git a/1.Vue/src/shared/constants.js b/1.Vue/src/shared/constants.js
deleted file mode 100644
index a8b15e0..0000000
--- a/1.Vue/src/shared/constants.js
+++ /dev/null
@@ -1,22 +0,0 @@
-export const SSR_ATTR = 'data-server-rendered'
-
-export const ASSET_TYPES = [
-  'component',
-  'directive',
-  'filter'
-]
-
-export const LIFECYCLE_HOOKS = [
-  'beforeCreate',
-  'created',
-  'beforeMount',
-  'mounted',
-  'beforeUpdate',
-  'updated',
-  'beforeDestroy',
-  'destroyed',
-  'activated',
-  'deactivated',
-  'errorCaptured',
-  'serverPrefetch'
-]
diff --git a/1.Vue/src/shared/util.js b/1.Vue/src/shared/util.js
deleted file mode 100644
index 9f240c7..0000000
--- a/1.Vue/src/shared/util.js
+++ /dev/null
@@ -1,343 +0,0 @@
-/* @flow */
-
-export const emptyObject = Object.freeze({})
-
-// These helpers produce better VM code in JS engines due to their
-// explicitness and function inlining.
-export function isUndef (v: any): boolean %checks {
-  return v === undefined || v === null
-}
-
-export function isDef (v: any): boolean %checks {
-  return v !== undefined && v !== null
-}
-
-export function isTrue (v: any): boolean %checks {
-  return v === true
-}
-
-export function isFalse (v: any): boolean %checks {
-  return v === false
-}
-
-/**
- * Check if value is primitive.
- */
-export function isPrimitive (value: any): boolean %checks {
-  return (
-    typeof value === 'string' ||
-    typeof value === 'number' ||
-    // $flow-disable-line
-    typeof value === 'symbol' ||
-    typeof value === 'boolean'
-  )
-}
-
-/**
- * Quick object check - this is primarily used to tell
- * Objects from primitive values when we know the value
- * is a JSON-compliant type.
- */
-export function isObject (obj: mixed): boolean %checks {
-  return obj !== null && typeof obj === 'object'
-}
-
-/**
- * Get the raw type string of a value, e.g., [object Object].
- */
-const _toString = Object.prototype.toString
-
-export function toRawType (value: any): string {
-  return _toString.call(value).slice(8, -1)
-}
-
-/**
- * Strict object type check. Only returns true
- * for plain JavaScript objects.
- */
-export function isPlainObject (obj: any): boolean {
-  return _toString.call(obj) === '[object Object]'
-}
-
-export function isRegExp (v: any): boolean {
-  return _toString.call(v) === '[object RegExp]'
-}
-
-/**
- * Check if val is a valid array index.
- */
-export function isValidArrayIndex (val: any): boolean {
-  const n = parseFloat(String(val))
-  return n >= 0 && Math.floor(n) === n && isFinite(val)
-}
-
-export function isPromise (val: any): boolean {
-  return (
-    isDef(val) &&
-    typeof val.then === 'function' &&
-    typeof val.catch === 'function'
-  )
-}
-
-/**
- * Convert a value to a string that is actually rendered.
- */
-export function toString (val: any): string {
-  return val == null
-    ? ''
-    : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
-      ? JSON.stringify(val, null, 2)
-      : String(val)
-}
-
-/**
- * Convert an input value to a number for persistence.
- * If the conversion fails, return original string.
- */
-export function toNumber (val: string): number | string {
-  const n = parseFloat(val)
-  return isNaN(n) ? val : n
-}
-
-/**
- * Make a map and return a function for checking if a key
- * is in that map.
- */
-export function makeMap (
-  str: string,
-  expectsLowerCase?: boolean
-): (key: string) => true | void {
-  const map = Object.create(null)
-  const list: Array<string> = str.split(',')
-  for (let i = 0; i < list.length; i++) {
-    map[list[i]] = true
-  }
-  return expectsLowerCase
-    ? val => map[val.toLowerCase()]
-    : val => map[val]
-}
-
-/**
- * Check if a tag is a built-in tag.
- */
-export const isBuiltInTag = makeMap('slot,component', true)
-
-/**
- * Check if an attribute is a reserved attribute.
- */
-export const isReservedAttribute = makeMap('key,ref,slot,slot-scope,is')
-
-/**
- * Remove an item from an array.
- */
-export function remove (arr: Array<any>, item: any): Array<any> | void {
-  if (arr.length) {
-    const index = arr.indexOf(item)
-    if (index > -1) {
-      return arr.splice(index, 1)
-    }
-  }
-}
-
-/**
- * Check whether an object has the property.
- */
-const hasOwnProperty = Object.prototype.hasOwnProperty
-export function hasOwn (obj: Object | Array<*>, key: string): boolean {
-  return hasOwnProperty.call(obj, key)
-}
-
-/**
- * Create a cached version of a pure function.
- */
-export function cached<F: Function> (fn: F): F {
-  const cache = Object.create(null)
-  return (function cachedFn (str: string) {
-    const hit = cache[str]
-    return hit || (cache[str] = fn(str))
-  }: any)
-}
-
-/**
- * Camelize a hyphen-delimited string.
- */
-const camelizeRE = /-(\w)/g
-export const camelize = cached((str: string): string => {
-  return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : '')
-})
-
-/**
- * Capitalize a string.
- */
-export const capitalize = cached((str: string): string => {
-  return str.charAt(0).toUpperCase() + str.slice(1)
-})
-
-/**
- * Hyphenate a camelCase string.
- */
-const hyphenateRE = /\B([A-Z])/g
-export const hyphenate = cached((str: string): string => {
-  return str.replace(hyphenateRE, '-$1').toLowerCase()
-})
-
-/**
- * Simple bind polyfill for environments that do not support it,
- * e.g., PhantomJS 1.x. Technically, we don't need this anymore
- * since native bind is now performant enough in most browsers.
- * But removing it would mean breaking code that was able to run in
- * PhantomJS 1.x, so this must be kept for backward compatibility.
- */
-
-/* istanbul ignore next */
-function polyfillBind (fn: Function, ctx: Object): Function {
-  function boundFn (a) {
-    const l = arguments.length
-    return l
-      ? l > 1
-        ? fn.apply(ctx, arguments)
-        : fn.call(ctx, a)
-      : fn.call(ctx)
-  }
-
-  boundFn._length = fn.length
-  return boundFn
-}
-
-function nativeBind (fn: Function, ctx: Object): Function {
-  return fn.bind(ctx)
-}
-
-export const bind = Function.prototype.bind
-  ? nativeBind
-  : polyfillBind
-
-/**
- * Convert an Array-like object to a real Array.
- */
-export function toArray (list: any, start?: number): Array<any> {
-  start = start || 0
-  let i = list.length - start
-  const ret: Array<any> = new Array(i)
-  while (i--) {
-    ret[i] = list[i + start]
-  }
-  return ret
-}
-
-/**
- * Mix properties into target object.
- */
-export function extend (to: Object, _from: ?Object): Object {
-  for (const key in _from) {
-    to[key] = _from[key]
-  }
-  return to
-}
-
-/**
- * Merge an Array of Objects into a single Object.
- */
-export function toObject (arr: Array<any>): Object {
-  const res = {}
-  for (let i = 0; i < arr.length; i++) {
-    if (arr[i]) {
-      extend(res, arr[i])
-    }
-  }
-  return res
-}
-
-/* eslint-disable no-unused-vars */
-
-/**
- * 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/).
- */
-export function noop (a?: any, b?: any, c?: any) {}
-
-/**
- * Always return false.
- */
-export const no = (a?: any, b?: any, c?: any) => false
-
-/* eslint-enable no-unused-vars */
-
-/**
- * Return the same value.
- */
-export const identity = (_: any) => _
-
-/**
- * Generate a string containing static keys from compiler modules.
- */
-export function genStaticKeys (modules: Array<ModuleOptions>): string {
-  return modules.reduce((keys, m) => {
-    return keys.concat(m.staticKeys || [])
-  }, []).join(',')
-}
-
-/**
- * Check if two values are loosely equal - that is,
- * if they are plain objects, do they have the same shape?
- */
-export function looseEqual (a: any, b: any): boolean {
-  if (a === b) return true
-  const isObjectA = isObject(a)
-  const isObjectB = isObject(b)
-  if (isObjectA && isObjectB) {
-    try {
-      const isArrayA = Array.isArray(a)
-      const isArrayB = Array.isArray(b)
-      if (isArrayA && isArrayB) {
-        return a.length === b.length && a.every((e, i) => {
-          return looseEqual(e, b[i])
-        })
-      } else if (a instanceof Date && b instanceof Date) {
-        return a.getTime() === b.getTime()
-      } else if (!isArrayA && !isArrayB) {
-        const keysA = Object.keys(a)
-        const keysB = Object.keys(b)
-        return keysA.length === keysB.length && keysA.every(key => {
-          return looseEqual(a[key], b[key])
-        })
-      } else {
-        /* istanbul ignore next */
-        return false
-      }
-    } catch (e) {
-      /* istanbul ignore next */
-      return false
-    }
-  } else if (!isObjectA && !isObjectB) {
-    return String(a) === String(b)
-  } else {
-    return false
-  }
-}
-
-/**
- * Return the first index at which a loosely equal value can be
- * found in the array (if value is a plain object, the array must
- * contain an object of the same shape), or -1 if it is not present.
- */
-export function looseIndexOf (arr: Array<mixed>, val: mixed): number {
-  for (let i = 0; i < arr.length; i++) {
-    if (looseEqual(arr[i], val)) return i
-  }
-  return -1
-}
-
-/**
- * Ensure a function is called only once.
- */
-export function once (fn: Function): Function {
-  let called = false
-  return function () {
-    if (!called) {
-      called = true
-      fn.apply(this, arguments)
-    }
-  }
-}
diff --git a/1.Vue/test/e2e/.eslintrc.json b/1.Vue/test/e2e/.eslintrc.json
deleted file mode 100644
index e866525..0000000
--- a/1.Vue/test/e2e/.eslintrc.json
+++ /dev/null
@@ -1,5 +0,0 @@
-{
-  "rules": {
-    "indent": 0
-  }
-}
diff --git a/1.Vue/test/e2e/nightwatch.config.js b/1.Vue/test/e2e/nightwatch.config.js
deleted file mode 100644
index 2004f92..0000000
--- a/1.Vue/test/e2e/nightwatch.config.js
+++ /dev/null
@@ -1,57 +0,0 @@
-// http://nightwatchjs.org/guide#settings-file
-module.exports = {
-  'src_folders': ['test/e2e/specs'],
-  'output_folder': 'test/e2e/reports',
-  'custom_commands_path': ['node_modules/nightwatch-helpers/commands'],
-  'custom_assertions_path': ['node_modules/nightwatch-helpers/assertions'],
-
-  'selenium': {
-    'start_process': true,
-    'server_path': require('selenium-server').path,
-    'host': '127.0.0.1',
-    'port': 4444,
-    'cli_args': {
-      'webdriver.chrome.driver': require('chromedriver').path
-      // , 'webdriver.gecko.driver': require('geckodriver').path
-    }
-  },
-
-  'test_settings': {
-    'default': {
-      'selenium_port': 4444,
-      'selenium_host': 'localhost',
-      'silent': true,
-      'screenshots': {
-        'enabled': true,
-        'on_failure': true,
-        'on_error': false,
-        'path': 'test/e2e/screenshots'
-      }
-    },
-
-    'chrome': {
-      'desiredCapabilities': {
-        'browserName': 'chrome',
-        'javascriptEnabled': true,
-        'acceptSslCerts': true
-      }
-    },
-
-    'firefox': {
-      'desiredCapabilities': {
-        'browserName': 'firefox',
-        'javascriptEnabled': true,
-        'acceptSslCerts': true,
-        'marionette': true
-      }
-    },
-
-    'phantomjs': {
-      'desiredCapabilities': {
-        'browserName': 'phantomjs',
-        'javascriptEnabled': true,
-        'acceptSslCerts': true
-      }
-    }
-  }
-}
diff --git a/1.Vue/test/e2e/runner.js b/1.Vue/test/e2e/runner.js
deleted file mode 100644
index dadce70..0000000
--- a/1.Vue/test/e2e/runner.js
+++ /dev/null
@@ -1,34 +0,0 @@
-const path = require('path')
-const spawn = require('cross-spawn')
-const httpServer = require('http-server')
-const server = httpServer.createServer({
-  root: path.resolve(__dirname, '../../')
-})
-
-server.listen(8080)
-
-let args = process.argv.slice(2)
-if (args.indexOf('--config') === -1) {
-  args = args.concat(['--config', 'test/e2e/nightwatch.config.js'])
-}
-if (args.indexOf('--env') === -1) {
-  args = args.concat(['--env', 'chrome,phantomjs'])
-}
-const i = args.indexOf('--test')
-if (i > -1) {
-  args[i + 1] = 'test/e2e/specs/' + args[i + 1] + '.js'
-}
-
-const runner = spawn('./node_modules/.bin/nightwatch', args, {
-  stdio: 'inherit'
-})
-
-runner.on('exit', function (code) {
-  server.close()
-  process.exit(code)
-})
-
-runner.on('error', function (err) {
-  server.close()
-  throw err
-})
diff --git a/1.Vue/test/e2e/specs/async-edge-cases.html b/1.Vue/test/e2e/specs/async-edge-cases.html
deleted file mode 100644
index 7bca8f8..0000000
--- a/1.Vue/test/e2e/specs/async-edge-cases.html
+++ /dev/null
@@ -1,53 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-  <head>
-    <meta charset="utf-8">
-    <title></title>
-    <script src="../../../dist/vue.min.js"></script>
-  </head>
-  <body>
-    <!-- #4510 click and change event on checkbox -->
-    <div id="case-1">
-      <div @click="num++">
-        {{ num }}
-        <input type="checkbox" v-model="checked">
-      </div>
-    </div>
-    <script>
-    var vm1 = new Vue({
-      el: '#case-1',
-      data: {
-        num: 1,
-        checked: false
-      }
-    })
-    </script>
-
-    <!-- #6566 click event bubbling -->
-    <div id="case-2">
-      <div class="panel" v-if="expand">
-        <button @click="expand = false, countA++">Expand is True</button>
-      </div>
-      <div class="header" v-if="!expand" @click="expand = true, countB++">
-        <button>Expand is False</button>
-      </div>
-      <div class="count-a">
-        countA: {{countA}}
-      </div>
-      <div class="count-b">
-        countB: {{countB}}
-      </div>
-    </div>
-    <script>
-    var vm2 = new Vue({
-      el: '#case-2',
-      data: {
-        expand: true,
-        countA: 0,
-        countB: 0,
-      }
-    })
-    </script>
-
-  </body>
-</html>
diff --git a/1.Vue/test/e2e/specs/async-edge-cases.js b/1.Vue/test/e2e/specs/async-edge-cases.js
deleted file mode 100644
index 27212b7..0000000
--- a/1.Vue/test/e2e/specs/async-edge-cases.js
+++ /dev/null
@@ -1,34 +0,0 @@
-module.exports = {
-  'async edge cases': function (browser) {
-    browser
-    .url('http://localhost:8080/test/e2e/specs/async-edge-cases.html')
-      // #4510
-      .assert.containsText('#case-1', '1')
-      .assert.checked('#case-1 input', false)
-
-      .click('#case-1 input')
-      .assert.containsText('#case-1', '2')
-      .assert.checked('#case-1 input', true)
-
-      .click('#case-1 input')
-      .assert.containsText('#case-1', '3')
-      .assert.checked('#case-1 input', false)
-
-      // // #6566
-      .assert.containsText('#case-2 button', 'Expand is True')
-      .assert.containsText('.count-a', 'countA: 0')
-      .assert.containsText('.count-b', 'countB: 0')
-
-      .click('#case-2 button')
-      .assert.containsText('#case-2 button', 'Expand is False')
-      .assert.containsText('.count-a', 'countA: 1')
-      .assert.containsText('.count-b', 'countB: 0')
-
-      .click('#case-2 button')
-      .assert.containsText('#case-2 button', 'Expand is True')
-      .assert.containsText('.count-a', 'countA: 1')
-      .assert.containsText('.count-b', 'countB: 1')
-
-      .end()
-  }
-}
diff --git a/1.Vue/test/e2e/specs/basic-ssr.html b/1.Vue/test/e2e/specs/basic-ssr.html
deleted file mode 100644
index 67f0dac..0000000
--- a/1.Vue/test/e2e/specs/basic-ssr.html
+++ /dev/null
@@ -1,24 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-  <head>
-    <meta charset="utf-8">
-    <title></title>
-  </head>
-  <body>
-    <script src="../../../dist/vue.min.js"></script>
-    <script src="../../../packages/vue-server-renderer/basic.js"></script>
-
-    <div id="result">wtf</div>
-
-    <script>
-    var vm = new Vue({
-      data: { msg: 'foo' },
-      template: '<div>{{ msg }}</div>'
-    })
-
-    renderVueComponentToString(vm, function (err, result) {
-      document.getElementById('result').textContent = err && err.toString() || result
-    })
-    </script>
-  </body>
-</html>
diff --git a/1.Vue/test/e2e/specs/basic-ssr.js b/1.Vue/test/e2e/specs/basic-ssr.js
deleted file mode 100644
index b1ea240..0000000
--- a/1.Vue/test/e2e/specs/basic-ssr.js
+++ /dev/null
@@ -1,8 +0,0 @@
-module.exports = {
-  'basic SSR': function (browser) {
-    browser
-    .url('http://localhost:8080/test/e2e/specs/basic-ssr.html')
-      .assert.containsText('#result', '<div data-server-rendered="true">foo</div>')
-      .end()
-  }
-}
diff --git a/1.Vue/test/e2e/specs/commits.js b/1.Vue/test/e2e/specs/commits.js
deleted file mode 100644
index cf81527..0000000
--- a/1.Vue/test/e2e/specs/commits.js
+++ /dev/null
@@ -1,23 +0,0 @@
-module.exports = {
-  'commits': function (browser) {
-    browser
-    .url('http://localhost:8080/examples/commits/')
-      .waitForElementVisible('li', 5000)
-      .assert.count('input', 2)
-      .assert.count('label', 2)
-      .assert.containsText('label[for="master"]', 'master')
-      .assert.containsText('label[for="dev"]', 'dev')
-      .assert.checked('#master')
-      .assert.checked('#dev', false)
-      .assert.containsText('p', 'vuejs/vue@master')
-      .assert.count('li', 3)
-      .assert.count('li .commit', 3)
-      .assert.count('li .message', 3)
-      .click('#dev')
-      .assert.containsText('p', 'vuejs/vue@dev')
-      .assert.count('li', 3)
-      .assert.count('li .commit', 3)
-      .assert.count('li .message', 3)
-      .end()
-  }
-}
diff --git a/1.Vue/test/e2e/specs/grid.js b/1.Vue/test/e2e/specs/grid.js
deleted file mode 100644
index ab635b2..0000000
--- a/1.Vue/test/e2e/specs/grid.js
+++ /dev/null
@@ -1,105 +0,0 @@
-module.exports = {
-  'grid': function (browser) {
-    const columns = ['name', 'power']
-
-    browser
-    .url('http://localhost:8080/examples/grid/')
-      .waitForElementVisible('table', 1000)
-      .assert.count('th', 2)
-      .assert.count('th.active', 0)
-      .assert.containsText('th:nth-child(1)', 'Name')
-      .assert.containsText('th:nth-child(2)', 'Power')
-      assertTable([
-        { name: 'Chuck Norris', power: Infinity },
-        { name: 'Bruce Lee', power: 9000 },
-        { name: 'Jackie Chan', power: 7000 },
-        { name: 'Jet Li', power: 8000 }
-      ])
-
-    browser
-      .click('th:nth-child(1)')
-      .assert.count('th.active:nth-child(1)', 1)
-      .assert.count('th.active:nth-child(2)', 0)
-      .assert.count('th:nth-child(1) .arrow.dsc', 1)
-      .assert.count('th:nth-child(2) .arrow.dsc', 0)
-      assertTable([
-        { name: 'Jet Li', power: 8000 },
-        { name: 'Jackie Chan', power: 7000 },
-        { name: 'Chuck Norris', power: Infinity },
-        { name: 'Bruce Lee', power: 9000 }
-      ])
-
-    browser
-      .click('th:nth-child(2)')
-      .assert.count('th.active:nth-child(1)', 0)
-      .assert.count('th.active:nth-child(2)', 1)
-      .assert.count('th:nth-child(1) .arrow.dsc', 1)
-      .assert.count('th:nth-child(2) .arrow.dsc', 1)
-      assertTable([
-        { name: 'Chuck Norris', power: Infinity },
-        { name: 'Bruce Lee', power: 9000 },
-        { name: 'Jet Li', power: 8000 },
-        { name: 'Jackie Chan', power: 7000 }
-      ])
-
-    browser
-      .click('th:nth-child(2)')
-      .assert.count('th.active:nth-child(1)', 0)
-      .assert.count('th.active:nth-child(2)', 1)
-      .assert.count('th:nth-child(1) .arrow.dsc', 1)
-      .assert.count('th:nth-child(2) .arrow.asc', 1)
-      assertTable([
-        { name: 'Jackie Chan', power: 7000 },
-        { name: 'Jet Li', power: 8000 },
-        { name: 'Bruce Lee', power: 9000 },
-        { name: 'Chuck Norris', power: Infinity }
-      ])
-
-    browser
-      .click('th:nth-child(1)')
-      .assert.count('th.active:nth-child(1)', 1)
-      .assert.count('th.active:nth-child(2)', 0)
-      .assert.count('th:nth-child(1) .arrow.asc', 1)
-      .assert.count('th:nth-child(2) .arrow.asc', 1)
-      assertTable([
-        { name: 'Bruce Lee', power: 9000 },
-        { name: 'Chuck Norris', power: Infinity },
-        { name: 'Jackie Chan', power: 7000 },
-        { name: 'Jet Li', power: 8000 }
-      ])
-
-    browser
-      .setValue('input[name="query"]', 'j')
-      assertTable([
-        { name: 'Jackie Chan', power: 7000 },
-        { name: 'Jet Li', power: 8000 }
-      ])
-
-    browser
-      .clearValue('input[name="query"]')
-      .setValue('input[name="query"]', 'infinity')
-      assertTable([
-        { name: 'Chuck Norris', power: Infinity }
-      ])
-
-    browser
-      .clearValue('input[name="query"]')
-      .assert.count('p', 0)
-      .setValue('input[name="query"]', 'stringthatdoesnotexistanywhere')
-      .assert.count('p', 1)
-
-    browser.end()
-
-    function assertTable (data) {
-      browser.assert.count('td', data.length * columns.length)
-      for (let i = 0; i < data.length; i++) {
-        for (let j = 0; j < columns.length; j++) {
-          browser.assert.containsText(
-            'tr:nth-child(' + (i + 1) + ') td:nth-child(' + (j + 1) + ')',
-            data[i][columns[j]]
-          )
-        }
-      }
-    }
-  }
-}
diff --git a/1.Vue/test/e2e/specs/markdown.js b/1.Vue/test/e2e/specs/markdown.js
deleted file mode 100644
index 84be2b4..0000000
--- a/1.Vue/test/e2e/specs/markdown.js
+++ /dev/null
@@ -1,19 +0,0 @@
-module.exports = {
-  'markdown': function (browser) {
-    browser
-    .url('http://localhost:8080/examples/markdown/')
-      .waitForElementVisible('#editor', 1000)
-      .assert.value('textarea', '# hello')
-      .assert.hasHTML('#editor div', '<h1 id="hello">hello</h1>')
-      .setValue('textarea', '\n## foo\n\n- bar\n- baz')
-      // assert the output is not updated yet because of debounce
-      .assert.hasHTML('#editor div', '<h1 id="hello">hello</h1>')
-      .waitFor(500)
-      .assert.hasHTML('#editor div',
-        '<h1 id="hello">hello</h1>\n' +
-        '<h2 id="foo">foo</h2>\n' +
-        '<ul>\n<li>bar</li>\n<li>baz</li>\n</ul>'
-      )
-      .end()
-  }
-}
diff --git a/1.Vue/test/e2e/specs/modal.js b/1.Vue/test/e2e/specs/modal.js
deleted file mode 100644
index 947bab1..0000000
--- a/1.Vue/test/e2e/specs/modal.js
+++ /dev/null
@@ -1,27 +0,0 @@
-module.exports = {
-  'modal': function (browser) {
-    browser
-    .url('http://localhost:8080/examples/modal/')
-      .waitForElementVisible('#app', 1000)
-      .assert.elementNotPresent('.modal-mask')
-      .click('#show-modal')
-      .assert.elementPresent('.modal-mask')
-      .assert.elementPresent('.modal-wrapper')
-      .assert.elementPresent('.modal-container')
-      .waitFor(50)
-      .assert.cssClassPresent('.modal-mask', 'modal-enter-active')
-      .waitFor(300)
-      .assert.cssClassNotPresent('.modal-mask', 'modal-enter-active')
-      .assert.containsText('.modal-header h3', 'custom header')
-      .assert.containsText('.modal-body', 'default body')
-      .assert.containsText('.modal-footer', 'default footer')
-      .click('.modal-default-button')
-      // should have transition
-      .assert.elementPresent('.modal-mask')
-      .waitFor(50)
-      .assert.cssClassPresent('.modal-mask', 'modal-leave-active')
-      .waitFor(300)
-      .assert.elementNotPresent('.modal-mask')
-      .end()
-  }
-}
diff --git a/1.Vue/test/e2e/specs/select2.js b/1.Vue/test/e2e/specs/select2.js
deleted file mode 100644
index ada225d..0000000
--- a/1.Vue/test/e2e/specs/select2.js
+++ /dev/null
@@ -1,46 +0,0 @@
-/* globals vm */
-module.exports = {
-  'select2': function (browser) {
-    browser
-    .url('http://localhost:8080/examples/select2/')
-      .waitForElementVisible('.select2', 1000)
-      .assert.elementPresent('select')
-      .assert.containsText('p', 'Selected: 0')
-      .assert.containsText('span.select2', 'Select one')
-
-      .click('.select2-selection__rendered')
-      .assert.count('.select2-results__option', 3)
-      .assert.containsText('.select2-results__option:nth-child(1)', 'Select one')
-      .assert.containsText('.select2-results__option:nth-child(2)', 'Hello')
-      .assert.containsText('.select2-results__option:nth-child(3)', 'World')
-      .assert.attributePresent('.select2-results__option:nth-child(1)', 'aria-disabled')
-
-      .click('.select2-results__option:nth-child(2)')
-      .assert.count('.select2-results__option', 0)
-      .assert.containsText('p', 'Selected: 1')
-      .assert.containsText('span.select2', 'Hello')
-
-      // test dynamic options
-      .execute(function () {
-        vm.options.push({ id: 3, text: 'Vue' })
-      })
-      .click('.select2-selection__rendered')
-      .assert.count('.select2-results__option', 4)
-      .assert.containsText('.select2-results__option:nth-child(1)', 'Select one')
-      .assert.containsText('.select2-results__option:nth-child(2)', 'Hello')
-      .assert.containsText('.select2-results__option:nth-child(3)', 'World')
-      .assert.containsText('.select2-results__option:nth-child(4)', 'Vue')
-
-      .click('.select2-results__option:nth-child(4)')
-      .assert.count('.select2-results__option', 0)
-      .assert.containsText('p', 'Selected: 3')
-      .assert.containsText('span.select2', 'Vue')
-
-      .execute(function () {
-        vm.selected = 2
-      })
-      .assert.containsText('p', 'Selected: 2')
-      .assert.containsText('span.select2', 'World')
-      .end()
-  }
-}
diff --git a/1.Vue/test/e2e/specs/svg.js b/1.Vue/test/e2e/specs/svg.js
deleted file mode 100644
index cc9af55..0000000
--- a/1.Vue/test/e2e/specs/svg.js
+++ /dev/null
@@ -1,48 +0,0 @@
-/* globals stats, valueToPoint */
-module.exports = {
-  'svg': function (browser) {
-    browser
-    .url('http://localhost:8080/examples/svg/')
-      .waitForElementVisible('svg', 1000)
-      .assert.count('g', 1)
-      .assert.count('polygon', 1)
-      .assert.count('circle', 1)
-      .assert.count('text', 6)
-      .assert.count('label', 6)
-      .assert.count('button', 7)
-      .assert.count('input[type="range"]', 6)
-      .assert.evaluate(function () {
-        const points = stats.map(function (stat, i) {
-        const point = valueToPoint(stat.value, i, 6)
-          return point.x + ',' + point.y
-        }).join(' ')
-        return document.querySelector('polygon').attributes[0].value === points
-      })
-      .click('button.remove')
-      .assert.count('text', 5)
-      .assert.count('label', 5)
-      .assert.count('button', 6)
-      .assert.count('input[type="range"]', 5)
-      .assert.evaluate(function () {
-        const points = stats.map(function (stat, i) {
-        const point = valueToPoint(stat.value, i, 5)
-          return point.x + ',' + point.y
-        }).join(' ')
-        return document.querySelector('polygon').attributes[0].value === points
-      })
-      .setValue('input[name="newlabel"]', 'foo')
-      .click('#add > button')
-      .assert.count('text', 6)
-      .assert.count('label', 6)
-      .assert.count('button', 7)
-      .assert.count('input[type="range"]', 6)
-      .assert.evaluate(function () {
-        const points = stats.map(function (stat, i) {
-        const point = valueToPoint(stat.value, i, 6)
-          return point.x + ',' + point.y
-        }).join(' ')
-        return document.querySelector('polygon').attributes[0].value === points
-      })
-      .end()
-  }
-}
diff --git a/1.Vue/test/e2e/specs/todomvc.js b/1.Vue/test/e2e/specs/todomvc.js
deleted file mode 100644
index 7720b04..0000000
--- a/1.Vue/test/e2e/specs/todomvc.js
+++ /dev/null
@@ -1,166 +0,0 @@
-module.exports = {
-  'todomvc': function (browser) {
-    browser
-    .url('http://localhost:8080/examples/todomvc/#test')
-      .waitForElementVisible('.todoapp', 1000)
-      .assert.notVisible('.main')
-      .assert.notVisible('.footer')
-      .assert.count('.filters .selected', 1)
-      .assert.evaluate(function () {
-        return document.querySelector('.filters .selected').textContent === 'All'
-      })
-
-    createNewItem('test')
-      .assert.count('.todo', 1)
-      .assert.notVisible('.todo .edit')
-      .assert.containsText('.todo label', 'test')
-      .assert.containsText('.todo-count strong', '1')
-      .assert.checked('.todo .toggle', false)
-      .assert.visible('.main')
-      .assert.visible('.footer')
-      .assert.notVisible('.clear-completed')
-      .assert.value('.new-todo', '')
-
-    createNewItem('test2')
-      .assert.count('.todo', 2)
-      .assert.containsText('.todo:nth-child(2) label', 'test2')
-      .assert.containsText('.todo-count strong', '2')
-
-    // toggle
-    browser
-      .click('.todo .toggle')
-      .assert.count('.todo.completed', 1)
-      .assert.cssClassPresent('.todo:nth-child(1)', 'completed')
-      .assert.containsText('.todo-count strong', '1')
-      .assert.visible('.clear-completed')
-
-    createNewItem('test3')
-      .assert.count('.todo', 3)
-      .assert.containsText('.todo:nth-child(3) label', 'test3')
-      .assert.containsText('.todo-count strong', '2')
-
-    createNewItem('test4')
-    createNewItem('test5')
-      .assert.count('.todo', 5)
-      .assert.containsText('.todo-count strong', '4')
-
-    // toggle more
-    browser
-      .click('.todo:nth-child(4) .toggle')
-      .click('.todo:nth-child(5) .toggle')
-      .assert.count('.todo.completed', 3)
-      .assert.containsText('.todo-count strong', '2')
-
-    // remove
-    removeItemAt(1)
-      .assert.count('.todo', 4)
-      .assert.count('.todo.completed', 2)
-      .assert.containsText('.todo-count strong', '2')
-    removeItemAt(2)
-      .assert.count('.todo', 3)
-      .assert.count('.todo.completed', 2)
-      .assert.containsText('.todo-count strong', '1')
-
-    // remove all
-    browser
-      .click('.clear-completed')
-      .assert.count('.todo', 1)
-      .assert.containsText('.todo label', 'test2')
-      .assert.count('.todo.completed', 0)
-      .assert.containsText('.todo-count strong', '1')
-      .assert.notVisible('.clear-completed')
-
-    // prepare to test filters
-    createNewItem('test')
-    createNewItem('test')
-      .click('.todo:nth-child(2) .toggle')
-      .click('.todo:nth-child(3) .toggle')
-
-    // active filter
-    browser
-      .click('.filters li:nth-child(2) a')
-      .assert.count('.todo', 1)
-      .assert.count('.todo.completed', 0)
-      // add item with filter active
-      createNewItem('test')
-      .assert.count('.todo', 2)
-
-    // completed filter
-    browser.click('.filters li:nth-child(3) a')
-      .assert.count('.todo', 2)
-      .assert.count('.todo.completed', 2)
-
-    // filter on page load
-    browser.url('http://localhost:8080/examples/todomvc/#active')
-      .assert.count('.todo', 2)
-      .assert.count('.todo.completed', 0)
-      .assert.containsText('.todo-count strong', '2')
-
-    // completed on page load
-    browser.url('http://localhost:8080/examples/todomvc/#completed')
-      .assert.count('.todo', 2)
-      .assert.count('.todo.completed', 2)
-      .assert.containsText('.todo-count strong', '2')
-
-    // toggling with filter active
-    browser
-      .click('.todo .toggle')
-      .assert.count('.todo', 1)
-      .click('.filters li:nth-child(2) a')
-      .assert.count('.todo', 3)
-      .click('.todo .toggle')
-      .assert.count('.todo', 2)
-
-    // editing triggered by blur
-    browser
-      .click('.filters li:nth-child(1) a')
-      .dblClick('.todo:nth-child(1) label')
-      .assert.count('.todo.editing', 1)
-      .assert.focused('.todo:nth-child(1) .edit')
-      .clearValue('.todo:nth-child(1) .edit')
-      .setValue('.todo:nth-child(1) .edit', 'edited!')
-      .click('.new-todo') // blur
-      .assert.count('.todo.editing', 0)
-      .assert.containsText('.todo:nth-child(1) label', 'edited!')
-
-    // editing triggered by enter
-    browser
-      .dblClick('.todo label')
-      .enterValue('.todo:nth-child(1) .edit', 'edited again!')
-      .assert.count('.todo.editing', 0)
-      .assert.containsText('.todo:nth-child(1) label', 'edited again!')
-
-    // cancel
-    browser
-      .dblClick('.todo label')
-      .clearValue('.todo:nth-child(1) .edit')
-      .setValue('.todo:nth-child(1) .edit', 'edited!')
-      .trigger('.todo:nth-child(1) .edit', 'keyup', 27)
-      .assert.count('.todo.editing', 0)
-      .assert.containsText('.todo:nth-child(1) label', 'edited again!')
-
-    // empty value should remove
-    browser
-      .dblClick('.todo label')
-      .enterValue('.todo:nth-child(1) .edit', ' ')
-      .assert.count('.todo', 3)
-
-    // toggle all
-    browser
-      .click('.toggle-all')
-      .assert.count('.todo.completed', 3)
-      .click('.toggle-all')
-      .assert.count('.todo:not(.completed)', 3)
-      .end()
-
-    function createNewItem (text) {
-      return browser.enterValue('.new-todo', text)
-    }
-
-    function removeItemAt (n) {
-      return browser
-        .moveToElement('.todo:nth-child(' + n + ')', 10, 10)
-        .click('.todo:nth-child(' + n + ') .destroy')
-    }
-  }
-}
diff --git a/1.Vue/test/e2e/specs/tree.js b/1.Vue/test/e2e/specs/tree.js
deleted file mode 100644
index 08df908..0000000
--- a/1.Vue/test/e2e/specs/tree.js
+++ /dev/null
@@ -1,72 +0,0 @@
-module.exports = {
-  'tree': function (browser) {
-    browser
-    .url('http://localhost:8080/examples/tree/')
-      .waitForElementVisible('li', 1000)
-      .assert.count('.item', 12)
-      .assert.count('.add', 4)
-      .assert.count('.item > ul', 4)
-      .assert.notVisible('#demo li ul')
-      .assert.containsText('#demo li div span', '[+]')
-
-      // expand root
-      .click('.bold')
-      .assert.visible('#demo ul')
-      .assert.evaluate(function () {
-        return document.querySelector('#demo li ul').children.length === 4
-      })
-      .assert.containsText('#demo li div span', '[-]')
-      .assert.containsText('#demo > .item > ul > .item:nth-child(1)', 'hello')
-      .assert.containsText('#demo > .item > ul > .item:nth-child(2)', 'wat')
-      .assert.containsText('#demo > .item > ul > .item:nth-child(3)', 'child folder')
-      .assert.containsText('#demo > .item > ul > .item:nth-child(3)', '[+]')
-
-      // add items to root
-      .click('#demo > .item > ul > .add')
-      .assert.evaluate(function () {
-        return document.querySelector('#demo li ul').children.length === 5
-      })
-      .assert.containsText('#demo > .item > ul > .item:nth-child(1)', 'hello')
-      .assert.containsText('#demo > .item > ul > .item:nth-child(2)', 'wat')
-      .assert.containsText('#demo > .item > ul > .item:nth-child(3)', 'child folder')
-      .assert.containsText('#demo > .item > ul > .item:nth-child(3)', '[+]')
-      .assert.containsText('#demo > .item > ul > .item:nth-child(4)', 'new stuff')
-
-      // add another item
-      .click('#demo > .item > ul > .add')
-      .assert.evaluate(function () {
-        return document.querySelector('#demo li ul').children.length === 6
-      })
-      .assert.containsText('#demo > .item > ul > .item:nth-child(1)', 'hello')
-      .assert.containsText('#demo > .item > ul > .item:nth-child(2)', 'wat')
-      .assert.containsText('#demo > .item > ul > .item:nth-child(3)', 'child folder')
-      .assert.containsText('#demo > .item > ul > .item:nth-child(3)', '[+]')
-      .assert.containsText('#demo > .item > ul > .item:nth-child(4)', 'new stuff')
-      .assert.containsText('#demo > .item > ul > .item:nth-child(5)', 'new stuff')
-
-      .click('#demo ul .bold')
-      .assert.visible('#demo ul ul')
-      .assert.containsText('#demo ul > .item:nth-child(3)', '[-]')
-      .assert.evaluate(function () {
-        return document.querySelector('#demo ul ul').children.length === 5
-      })
-
-      .click('.bold')
-      .assert.notVisible('#demo ul')
-      .assert.containsText('#demo li div span', '[+]')
-      .click('.bold')
-      .assert.visible('#demo ul')
-      .assert.containsText('#demo li div span', '[-]')
-
-      .dblClick('#demo ul > .item div')
-      .assert.count('.item', 15)
-      .assert.count('.item > ul', 5)
-      .assert.containsText('#demo ul > .item:nth-child(1)', '[-]')
-      .assert.evaluate(function () {
-        const firstItem = document.querySelector('#demo ul > .item:nth-child(1)')
-        const ul = firstItem.querySelector('ul')
-        return ul.children.length === 2
-      })
-      .end()
-  }
-}
diff --git a/1.Vue/test/helpers/.eslintrc.json b/1.Vue/test/helpers/.eslintrc.json
deleted file mode 100644
index de3ffc6..0000000
--- a/1.Vue/test/helpers/.eslintrc.json
+++ /dev/null
@@ -1,8 +0,0 @@
-{
-  "env": {
-    "jasmine": true
-  },
-  "globals": {
-    "waitForUpdate": true
-  }
-}
diff --git a/1.Vue/test/helpers/classlist.js b/1.Vue/test/helpers/classlist.js
deleted file mode 100644
index 29e04b8..0000000
--- a/1.Vue/test/helpers/classlist.js
+++ /dev/null
@@ -1,18 +0,0 @@
-beforeEach(() => {
-  jasmine.addMatchers({
-    // since classList may not be supported in all browsers
-    toHaveClass: () => {
-      return {
-        compare: (el, cls) => {
-          const pass = el.classList
-            ? el.classList.contains(cls)
-            : el.getAttribute('class').split(/\s+/g).indexOf(cls) > -1
-          return {
-            pass,
-            message: `Expected element${pass ? ' ' : ' not '}to have class ${cls}`
-          }
-        }
-      }
-    }
-  })
-})
diff --git a/1.Vue/test/helpers/test-object-option.js b/1.Vue/test/helpers/test-object-option.js
deleted file mode 100644
index 0589292..0000000
--- a/1.Vue/test/helpers/test-object-option.js
+++ /dev/null
@@ -1,17 +0,0 @@
-import Vue from 'vue'
-
-export default function testObjectOption (name) {
-  it(`Options ${name}: should warn non object value`, () => {
-    const options = {}
-    options[name] = () => {}
-    new Vue(options)
-    expect(`Invalid value for option "${name}"`).toHaveBeenWarned()
-  })
-
-  it(`Options ${name}: should not warn valid object value`, () => {
-    const options = {}
-    options[name] = {}
-    new Vue(options)
-    expect(`Invalid value for option "${name}"`).not.toHaveBeenWarned()
-  })
-}
diff --git a/1.Vue/test/helpers/to-equal.js b/1.Vue/test/helpers/to-equal.js
deleted file mode 100644
index 33308bd..0000000
--- a/1.Vue/test/helpers/to-equal.js
+++ /dev/null
@@ -1,19 +0,0 @@
-import { isEqual } from 'lodash'
-
-beforeEach(() => {
-  jasmine.addMatchers({
-    // override built-in toEqual because it behaves incorrectly
-    // on Vue-observed arrays in Safari
-    toEqual: () => {
-      return {
-        compare: (a, b) => {
-          const pass = isEqual(a, b)
-          return {
-            pass,
-            message: `Expected ${a} to equal ${b}`
-          }
-        }
-      }
-    }
-  })
-})
diff --git a/1.Vue/test/helpers/to-have-been-warned.js b/1.Vue/test/helpers/to-have-been-warned.js
deleted file mode 100644
index b3a5eaa..0000000
--- a/1.Vue/test/helpers/to-have-been-warned.js
+++ /dev/null
@@ -1,70 +0,0 @@
-function noop () {}
-
-if (typeof console === 'undefined') {
-  window.console = {
-    warn: noop,
-    error: noop
-  }
-}
-
-// avoid info messages during test
-console.info = noop
-
-let asserted
-
-function createCompareFn (spy) {
-  const hasWarned = msg => {
-    let count = spy.calls.count()
-    let args
-    while (count--) {
-      args = spy.calls.argsFor(count)
-      if (args.some(containsMsg)) {
-        return true
-      }
-    }
-
-    function containsMsg (arg) {
-      return arg.toString().indexOf(msg) > -1
-    }
-  }
-
-  return {
-    compare: msg => {
-      asserted = asserted.concat(msg)
-      const warned = Array.isArray(msg)
-        ? msg.some(hasWarned)
-        : hasWarned(msg)
-      return {
-        pass: warned,
-        message: warned
-          ? 'Expected message "' + msg + '" not to have been warned'
-          : 'Expected message "' + msg + '" to have been warned'
-      }
-    }
-  }
-}
-
-// define custom matcher for warnings
-beforeEach(() => {
-  asserted = []
-  spyOn(console, 'warn')
-  spyOn(console, 'error')
-  jasmine.addMatchers({
-    toHaveBeenWarned: () => createCompareFn(console.error),
-    toHaveBeenTipped: () => createCompareFn(console.warn)
-  })
-})
-
-afterEach(done => {
-  const warned = msg => asserted.some(assertedMsg => msg.toString().indexOf(assertedMsg) > -1)
-  let count = console.error.calls.count()
-  let args
-  while (count--) {
-    args = console.error.calls.argsFor(count)
-    if (!warned(args[0])) {
-      done.fail(`Unexpected console.error message: ${args[0]}`)
-      return
-    }
-  }
-  done()
-})
diff --git a/1.Vue/test/helpers/trigger-event.js b/1.Vue/test/helpers/trigger-event.js
deleted file mode 100644
index e282513..0000000
--- a/1.Vue/test/helpers/trigger-event.js
+++ /dev/null
@@ -1,9 +0,0 @@
-window.triggerEvent = function triggerEvent (target, event, process) {
-  const e = document.createEvent('HTMLEvents')
-  e.initEvent(event, true, true)
-  if (event === 'click') {
-    e.button = 0
-  }
-  if (process) process(e)
-  target.dispatchEvent(e)
-}
diff --git a/1.Vue/test/helpers/vdom.js b/1.Vue/test/helpers/vdom.js
deleted file mode 100644
index abfb189..0000000
--- a/1.Vue/test/helpers/vdom.js
+++ /dev/null
@@ -1,5 +0,0 @@
-import VNode from 'core/vdom/vnode'
-
-window.createTextVNode = function (text) {
-  return new VNode(undefined, undefined, undefined, text)
-}
diff --git a/1.Vue/test/helpers/wait-for-update.js b/1.Vue/test/helpers/wait-for-update.js
deleted file mode 100644
index 37f87db..0000000
--- a/1.Vue/test/helpers/wait-for-update.js
+++ /dev/null
@@ -1,73 +0,0 @@
-import Vue from 'vue'
-
-// helper for async assertions.
-// Use like this:
-//
-// vm.a = 123
-// waitForUpdate(() => {
-//   expect(vm.$el.textContent).toBe('123')
-//   vm.a = 234
-// })
-// .then(() => {
-//   // more assertions...
-// })
-// .then(done)
-window.waitForUpdate = initialCb => {
-  let end
-  const queue = initialCb ? [initialCb] : []
-
-  function shift () {
-    const job = queue.shift()
-    if (queue.length) {
-      let hasError = false
-      try {
-        job.wait ? job(shift) : job()
-      } catch (e) {
-        hasError = true
-        const done = queue[queue.length - 1]
-        if (done && done.fail) {
-          done.fail(e)
-        }
-      }
-      if (!hasError && !job.wait) {
-        if (queue.length) {
-          Vue.nextTick(shift)
-        }
-      }
-    } else if (job && (job.fail || job === end)) {
-      job() // done
-    }
-  }
-
-  Vue.nextTick(() => {
-    if (!queue.length || (!end && !queue[queue.length - 1].fail)) {
-      throw new Error('waitForUpdate chain is missing .then(done)')
-    }
-    shift()
-  })
-
-  const chainer = {
-    then: nextCb => {
-      queue.push(nextCb)
-      return chainer
-    },
-    thenWaitFor: (wait) => {
-      if (typeof wait === 'number') {
-        wait = timeout(wait)
-      }
-      wait.wait = true
-      queue.push(wait)
-      return chainer
-    },
-    end: endFn => {
-      queue.push(endFn)
-      end = endFn
-    }
-  }
-
-  return chainer
-}
-
-function timeout (n) {
-  return next => setTimeout(next, n)
-}
diff --git a/1.Vue/test/ssr/.eslintrc b/1.Vue/test/ssr/.eslintrc
deleted file mode 100644
index dab5d0e..0000000
--- a/1.Vue/test/ssr/.eslintrc
+++ /dev/null
@@ -1,9 +0,0 @@
-{
-  "env": {
-    "jasmine": true
-  },
-  "plugins": ["jasmine"],
-  "rules": {
-    "jasmine/no-focused-tests": 2
-  }
-}
diff --git a/1.Vue/test/ssr/async-loader.js b/1.Vue/test/ssr/async-loader.js
deleted file mode 100644
index 41b4a98..0000000
--- a/1.Vue/test/ssr/async-loader.js
+++ /dev/null
@@ -1,6 +0,0 @@
-const hash = require('hash-sum')
-
-module.exports = function (code) {
-  const id = hash(this.request) // simulating vue-loader module id injection
-  return code.replace('__MODULE_ID__', id)
-}
diff --git a/1.Vue/test/ssr/compile-with-webpack.js b/1.Vue/test/ssr/compile-with-webpack.js
deleted file mode 100644
index 6e648c8..0000000
--- a/1.Vue/test/ssr/compile-with-webpack.js
+++ /dev/null
@@ -1,39 +0,0 @@
-import path from 'path'
-import webpack from 'webpack'
-import MemoryFS from 'memory-fs'
-
-export function compileWithWebpack (file, extraConfig, cb) {
-  const config = Object.assign({
-    mode: 'development',
-    entry: path.resolve(__dirname, 'fixtures', file),
-    module: {
-      rules: [
-        {
-          test: /\.js$/,
-          loader: 'babel-loader'
-        },
-        {
-          test: /async-.*\.js$/,
-          loader: require.resolve('./async-loader')
-        },
-        {
-          test: /\.(png|woff2|css)$/,
-          loader: 'file-loader',
-          options: {
-            name: '[name].[ext]'
-          }
-        }
-      ]
-    }
-  }, extraConfig)
-
-  const compiler = webpack(config)
-  const fs = new MemoryFS()
-  compiler.outputFileSystem = fs
-
-  compiler.run((err, stats) => {
-    expect(err).toBeFalsy()
-    expect(stats.errors).toBeFalsy()
-    cb(fs)
-  })
-}
diff --git a/1.Vue/test/ssr/fixtures/app.js b/1.Vue/test/ssr/fixtures/app.js
deleted file mode 100644
index 85bb288..0000000
--- a/1.Vue/test/ssr/fixtures/app.js
+++ /dev/null
@@ -1,12 +0,0 @@
-import Vue from '../../../dist/vue.runtime.common.js'
-
-export default context => {
-  return new Promise(resolve => {
-    context.msg = 'hello'
-    resolve(new Vue({
-      render (h) {
-        return h('div', context.url)
-      }
-    }))
-  })
-}
diff --git a/1.Vue/test/ssr/fixtures/async-bar.js b/1.Vue/test/ssr/fixtures/async-bar.js
deleted file mode 100644
index 5eb93c1..0000000
--- a/1.Vue/test/ssr/fixtures/async-bar.js
+++ /dev/null
@@ -1,8 +0,0 @@
-module.exports = {
-  beforeCreate () {
-    this.$vnode.ssrContext._registeredComponents.add('__MODULE_ID__')
-  },
-  render (h) {
-    return h('div', 'async bar')
-  }
-}
diff --git a/1.Vue/test/ssr/fixtures/async-foo.js b/1.Vue/test/ssr/fixtures/async-foo.js
deleted file mode 100644
index 59e0b9a..0000000
--- a/1.Vue/test/ssr/fixtures/async-foo.js
+++ /dev/null
@@ -1,13 +0,0 @@
-// import image and font
-import './test.css'
-import font from './test.woff2'
-import image from './test.png'
-
-export default {
-  beforeCreate () {
-    this.$vnode.ssrContext._registeredComponents.add('__MODULE_ID__')
-  },
-  render (h) {
-    return h('div', `async ${font} ${image}`)
-  }
-}
diff --git a/1.Vue/test/ssr/fixtures/cache-opt-out.js b/1.Vue/test/ssr/fixtures/cache-opt-out.js
deleted file mode 100644
index 772d403..0000000
--- a/1.Vue/test/ssr/fixtures/cache-opt-out.js
+++ /dev/null
@@ -1,16 +0,0 @@
-import Vue from '../../../dist/vue.runtime.common.js'
-
-const app = {
-  name: 'app',
-  props: ['id'],
-  serverCacheKey: props => props.id === 1 ? false : props.id,
-  render (h) {
-    return h('div', '/test')
-  }
-}
-
-export default () => {
-  return Promise.resolve(new Vue({
-    render: h => h(app, { props: { id: 1 }})
-  }))
-}
diff --git a/1.Vue/test/ssr/fixtures/cache.js b/1.Vue/test/ssr/fixtures/cache.js
deleted file mode 100644
index 2901677..0000000
--- a/1.Vue/test/ssr/fixtures/cache.js
+++ /dev/null
@@ -1,16 +0,0 @@
-import Vue from '../../../dist/vue.runtime.common.js'
-
-const app = {
-  name: 'app',
-  props: ['id'],
-  serverCacheKey: props => props.id,
-  render (h) {
-    return h('div', '/test')
-  }
-}
-
-export default () => {
-  return Promise.resolve(new Vue({
-    render: h => h(app, { props: { id: 1 }})
-  }))
-}
diff --git a/1.Vue/test/ssr/fixtures/error.js b/1.Vue/test/ssr/fixtures/error.js
deleted file mode 100644
index a4548e3..0000000
--- a/1.Vue/test/ssr/fixtures/error.js
+++ /dev/null
@@ -1 +0,0 @@
-throw new Error('foo')
diff --git a/1.Vue/test/ssr/fixtures/nested-cache.js b/1.Vue/test/ssr/fixtures/nested-cache.js
deleted file mode 100644
index 9f26568..0000000
--- a/1.Vue/test/ssr/fixtures/nested-cache.js
+++ /dev/null
@@ -1,49 +0,0 @@
-import Vue from '../../../dist/vue.runtime.common.js'
-
-function createRegisterFn (id) {
-  return function (context) {
-    context = context || this.$vnode.ssrContext
-    context.registered.push(id)
-  }
-}
-
-function addHooks (comp) {
-  const hook = createRegisterFn(comp.name)
-  return Object.assign(comp, {
-    _ssrRegister: hook,
-    beforeCreate: hook
-  })
-}
-
-const grandchild = addHooks({
-  name: 'grandchild',
-  props: ['id'],
-  serverCacheKey: props => props.id,
-  render (h) {
-    return h('div', '/test')
-  }
-})
-
-const child = addHooks({
-  name: 'child',
-  props: ['id'],
-  serverCacheKey: props => props.id,
-  render (h) {
-    return h(grandchild, { props: { id: this.id }})
-  }
-})
-
-const app = addHooks({
-  name: 'app',
-  props: ['id'],
-  serverCacheKey: props => props.id,
-  render (h) {
-    return h(child, { props: { id: this.id }})
-  }
-})
-
-export default () => {
-  return Promise.resolve(new Vue({
-    render: h => h(app, { props: { id: 1 }})
-  }))
-}
diff --git a/1.Vue/test/ssr/fixtures/promise-rejection.js b/1.Vue/test/ssr/fixtures/promise-rejection.js
deleted file mode 100644
index 40dcccf..0000000
--- a/1.Vue/test/ssr/fixtures/promise-rejection.js
+++ /dev/null
@@ -1,3 +0,0 @@
-export default () => {
-  return Promise.reject(new Error('foo'))
-}
diff --git a/1.Vue/test/ssr/fixtures/split.js b/1.Vue/test/ssr/fixtures/split.js
deleted file mode 100644
index 0282f10..0000000
--- a/1.Vue/test/ssr/fixtures/split.js
+++ /dev/null
@@ -1,26 +0,0 @@
-import Vue from '../../../dist/vue.runtime.common.js'
-
-// async component!
-const Foo = () => import('./async-foo')
-const Bar = () => import('./async-bar') // eslint-disable-line
-
-export default context => {
-  return new Promise(resolve => {
-    context.msg = 'hello'
-    const vm = new Vue({
-      render (h) {
-        return h('div', [
-          context.url,
-          h(Foo)
-        ])
-      }
-    })
-
-    // simulate router.onReady
-    Foo().then(comp => {
-      // resolve now to make the render sync
-      Foo.resolved = Vue.extend(comp.default)
-      resolve(vm)
-    })
-  })
-}
diff --git a/1.Vue/test/ssr/fixtures/test.css b/1.Vue/test/ssr/fixtures/test.css
deleted file mode 100644
index e69de29..0000000
diff --git a/1.Vue/test/ssr/fixtures/test.png b/1.Vue/test/ssr/fixtures/test.png
deleted file mode 100644
index e69de29..0000000
diff --git a/1.Vue/test/ssr/fixtures/test.woff2 b/1.Vue/test/ssr/fixtures/test.woff2
deleted file mode 100644
index e69de29..0000000
diff --git a/1.Vue/test/ssr/jasmine.js b/1.Vue/test/ssr/jasmine.js
deleted file mode 100644
index b632601..0000000
--- a/1.Vue/test/ssr/jasmine.js
+++ /dev/null
@@ -1,10 +0,0 @@
-module.exports = {
-  spec_dir: 'test/ssr',
-  spec_files: [
-    '*.spec.js'
-  ],
-  helpers: [
-    require.resolve('@babel/register'),
-    '../helpers/to-have-been-warned.js'
-  ]
-}
diff --git a/1.Vue/test/ssr/ssr-basic-renderer.spec.js b/1.Vue/test/ssr/ssr-basic-renderer.spec.js
deleted file mode 100644
index 09ce8e7..0000000
--- a/1.Vue/test/ssr/ssr-basic-renderer.spec.js
+++ /dev/null
@@ -1,70 +0,0 @@
-import Vue from '../../dist/vue.runtime.common.js'
-import renderToString from '../../packages/vue-server-renderer/basic'
-
-describe('SSR: basicRenderer', () => {
-  it('should work', done => {
-    renderToString(new Vue({
-      template: `
-        <div>
-          <p class="hi">yoyo</p>
-          <div id="ho" :class="{ red: isRed }"></div>
-          <span>{{ test }}</span>
-          <input :value="test">
-          <img :src="imageUrl">
-          <test></test>
-          <test-async></test-async>
-        </div>
-      `,
-      data: {
-        test: 'hi',
-        isRed: true,
-        imageUrl: 'https://vuejs.org/images/logo.png'
-      },
-      components: {
-        test: {
-          render () {
-            return this.$createElement('div', { class: ['a'] }, 'test')
-          }
-        },
-        testAsync (resolve) {
-          resolve({
-            render () {
-              return this.$createElement('span', { class: ['b'] }, 'testAsync')
-            }
-          })
-        }
-      }
-    }), (err, result) => {
-      expect(err).toBeNull()
-      expect(result).toContain(
-        '<div data-server-rendered="true">' +
-          '<p class="hi">yoyo</p> ' +
-          '<div id="ho" class="red"></div> ' +
-          '<span>hi</span> ' +
-          '<input value="hi"> ' +
-          '<img src="https://vuejs.org/images/logo.png"> ' +
-          '<div class="a">test</div> ' +
-          '<span class="b">testAsync</span>' +
-        '</div>'
-      )
-      done()
-    })
-  })
-
-  // #5941
-  it('should work peoperly when accessing $ssrContext in root component', done => {
-    let ssrContext
-    renderToString(new Vue({
-      template: `
-        <div></div>
-      `,
-      created () {
-        ssrContext = this.$ssrContext
-      }
-    }), (err) => {
-      expect(err).toBeNull()
-      expect(ssrContext).toBeUndefined()
-      done()
-    })
-  })
-})
diff --git a/1.Vue/test/ssr/ssr-bundle-render.spec.js b/1.Vue/test/ssr/ssr-bundle-render.spec.js
deleted file mode 100644
index ce7f878..0000000
--- a/1.Vue/test/ssr/ssr-bundle-render.spec.js
+++ /dev/null
@@ -1,347 +0,0 @@
-import LRU from 'lru-cache'
-import { compileWithWebpack } from './compile-with-webpack'
-import { createBundleRenderer } from '../../packages/vue-server-renderer'
-import VueSSRServerPlugin from '../../packages/vue-server-renderer/server-plugin'
-
-export function createRenderer (file, options, cb) {
-  if (typeof options === 'function') {
-    cb = options
-    options = undefined
-  }
-  const asBundle = !!(options && options.asBundle)
-  if (options) delete options.asBundle
-
-  compileWithWebpack(file, {
-    target: 'node',
-    devtool: asBundle ? '#source-map' : false,
-    output: {
-      path: '/',
-      filename: 'bundle.js',
-      libraryTarget: 'commonjs2'
-    },
-    externals: [require.resolve('../../dist/vue.runtime.common.js')],
-    plugins: asBundle
-      ? [new VueSSRServerPlugin()]
-      : []
-  }, fs => {
-    const bundle = asBundle
-      ? JSON.parse(fs.readFileSync('/vue-ssr-server-bundle.json', 'utf-8'))
-      : fs.readFileSync('/bundle.js', 'utf-8')
-    const renderer = createBundleRenderer(bundle, options)
-    cb(renderer)
-  })
-}
-
-describe('SSR: bundle renderer', () => {
-  createAssertions(true)
-  createAssertions(false)
-})
-
-function createAssertions (runInNewContext) {
-  it('renderToString', done => {
-    createRenderer('app.js', { runInNewContext }, renderer => {
-      const context = { url: '/test' }
-      renderer.renderToString(context, (err, res) => {
-        expect(err).toBeNull()
-        expect(res).toBe('<div data-server-rendered="true">/test</div>')
-        expect(context.msg).toBe('hello')
-        done()
-      })
-    })
-  })
-
-  it('renderToStream', done => {
-    createRenderer('app.js', { runInNewContext }, renderer => {
-      const context = { url: '/test' }
-      const stream = renderer.renderToStream(context)
-      let res = ''
-      stream.on('data', chunk => {
-        res += chunk.toString()
-      })
-      stream.on('end', () => {
-        expect(res).toBe('<div data-server-rendered="true">/test</div>')
-        expect(context.msg).toBe('hello')
-        done()
-      })
-    })
-  })
-
-  it('renderToString catch error', done => {
-    createRenderer('error.js', { runInNewContext }, renderer => {
-      renderer.renderToString(err => {
-        expect(err.message).toBe('foo')
-        done()
-      })
-    })
-  })
-
-  it('renderToString catch Promise rejection', done => {
-    createRenderer('promise-rejection.js', { runInNewContext }, renderer => {
-      renderer.renderToString(err => {
-        expect(err.message).toBe('foo')
-        done()
-      })
-    })
-  })
-
-  it('renderToStream catch error', done => {
-    createRenderer('error.js', { runInNewContext }, renderer => {
-      const stream = renderer.renderToStream()
-      stream.on('error', err => {
-        expect(err.message).toBe('foo')
-        done()
-      })
-    })
-  })
-
-  it('renderToStream catch Promise rejection', done => {
-    createRenderer('promise-rejection.js', { runInNewContext }, renderer => {
-      const stream = renderer.renderToStream()
-      stream.on('error', err => {
-        expect(err.message).toBe('foo')
-        done()
-      })
-    })
-  })
-
-  it('render with cache (get/set)', done => {
-    const cache = {}
-    const get = jasmine.createSpy('get')
-    const set = jasmine.createSpy('set')
-    const options = {
-      runInNewContext,
-      cache: {
-        // async
-        get: (key, cb) => {
-          setTimeout(() => {
-            get(key)
-            cb(cache[key])
-          }, 0)
-        },
-        set: (key, val) => {
-          set(key, val)
-          cache[key] = val
-        }
-      }
-    }
-    createRenderer('cache.js', options, renderer => {
-      const expected = '<div data-server-rendered="true">/test</div>'
-      const key = 'app::1'
-      renderer.renderToString((err, res) => {
-        expect(err).toBeNull()
-        expect(res).toBe(expected)
-        expect(get).toHaveBeenCalledWith(key)
-        const setArgs = set.calls.argsFor(0)
-        expect(setArgs[0]).toBe(key)
-        expect(setArgs[1].html).toBe(expected)
-        expect(cache[key].html).toBe(expected)
-        renderer.renderToString((err, res) => {
-          expect(err).toBeNull()
-          expect(res).toBe(expected)
-          expect(get.calls.count()).toBe(2)
-          expect(set.calls.count()).toBe(1)
-          done()
-        })
-      })
-    })
-  })
-
-  it('render with cache (get/set/has)', done => {
-    const cache = {}
-    const has = jasmine.createSpy('has')
-    const get = jasmine.createSpy('get')
-    const set = jasmine.createSpy('set')
-    const options = {
-      runInNewContext,
-      cache: {
-        // async
-        has: (key, cb) => {
-          has(key)
-          cb(!!cache[key])
-        },
-        // sync
-        get: key => {
-          get(key)
-          return cache[key]
-        },
-        set: (key, val) => {
-          set(key, val)
-          cache[key] = val
-        }
-      }
-    }
-    createRenderer('cache.js', options, renderer => {
-      const expected = '<div data-server-rendered="true">/test</div>'
-      const key = 'app::1'
-      renderer.renderToString((err, res) => {
-        expect(err).toBeNull()
-        expect(res).toBe(expected)
-        expect(has).toHaveBeenCalledWith(key)
-        expect(get).not.toHaveBeenCalled()
-        const setArgs = set.calls.argsFor(0)
-        expect(setArgs[0]).toBe(key)
-        expect(setArgs[1].html).toBe(expected)
-        expect(cache[key].html).toBe(expected)
-        renderer.renderToString((err, res) => {
-          expect(err).toBeNull()
-          expect(res).toBe(expected)
-          expect(has.calls.count()).toBe(2)
-          expect(get.calls.count()).toBe(1)
-          expect(set.calls.count()).toBe(1)
-          done()
-        })
-      })
-    })
-  })
-
-  it('render with cache (nested)', done => {
-    const cache = new LRU({ maxAge: Infinity })
-    spyOn(cache, 'get').and.callThrough()
-    spyOn(cache, 'set').and.callThrough()
-    const options = {
-      cache,
-      runInNewContext
-    }
-    createRenderer('nested-cache.js', options, renderer => {
-      const expected = '<div data-server-rendered="true">/test</div>'
-      const key = 'app::1'
-      const context1 = { registered: [] }
-      const context2 = { registered: [] }
-      renderer.renderToString(context1, (err, res) => {
-        expect(err).toBeNull()
-        expect(res).toBe(expected)
-        expect(cache.set.calls.count()).toBe(3) // 3 nested components cached
-        const cached = cache.get(key)
-        expect(cached.html).toBe(expected)
-        expect(cache.get.calls.count()).toBe(1)
-
-        // assert component usage registration for nested children
-        expect(context1.registered).toEqual(['app', 'child', 'grandchild'])
-
-        renderer.renderToString(context2, (err, res) => {
-          expect(err).toBeNull()
-          expect(res).toBe(expected)
-          expect(cache.set.calls.count()).toBe(3) // no new cache sets
-          expect(cache.get.calls.count()).toBe(2) // 1 get for root
-
-          expect(context2.registered).toEqual(['app', 'child', 'grandchild'])
-          done()
-        })
-      })
-    })
-  })
-
-  it('render with cache (opt-out)', done => {
-    const cache = {}
-    const get = jasmine.createSpy('get')
-    const set = jasmine.createSpy('set')
-    const options = {
-      runInNewContext,
-      cache: {
-        // async
-        get: (key, cb) => {
-          setTimeout(() => {
-            get(key)
-            cb(cache[key])
-          }, 0)
-        },
-        set: (key, val) => {
-          set(key, val)
-          cache[key] = val
-        }
-      }
-    }
-    createRenderer('cache-opt-out.js', options, renderer => {
-      const expected = '<div data-server-rendered="true">/test</div>'
-      renderer.renderToString((err, res) => {
-        expect(err).toBeNull()
-        expect(res).toBe(expected)
-        expect(get).not.toHaveBeenCalled()
-        expect(set).not.toHaveBeenCalled()
-        renderer.renderToString((err, res) => {
-          expect(err).toBeNull()
-          expect(res).toBe(expected)
-          expect(get).not.toHaveBeenCalled()
-          expect(set).not.toHaveBeenCalled()
-          done()
-        })
-      })
-    })
-  })
-
-  it('renderToString (bundle format with code split)', done => {
-    createRenderer('split.js', { runInNewContext, asBundle: true }, renderer => {
-      const context = { url: '/test' }
-      renderer.renderToString(context, (err, res) => {
-        expect(err).toBeNull()
-        expect(res).toBe('<div data-server-rendered="true">/test<div>async test.woff2 test.png</div></div>')
-        done()
-      })
-    })
-  })
-
-  it('renderToStream (bundle format with code split)', done => {
-    createRenderer('split.js', { runInNewContext, asBundle: true }, renderer => {
-      const context = { url: '/test' }
-      const stream = renderer.renderToStream(context)
-      let res = ''
-      stream.on('data', chunk => {
-        res += chunk.toString()
-      })
-      stream.on('end', () => {
-        expect(res).toBe('<div data-server-rendered="true">/test<div>async test.woff2 test.png</div></div>')
-        done()
-      })
-    })
-  })
-
-  it('renderToString catch error (bundle format with source map)', done => {
-    createRenderer('error.js', { runInNewContext, asBundle: true }, renderer => {
-      renderer.renderToString(err => {
-        expect(err.stack).toContain('test/ssr/fixtures/error.js:1:6')
-        expect(err.message).toBe('foo')
-        done()
-      })
-    })
-  })
-
-  it('renderToString catch error (bundle format with source map)', done => {
-    createRenderer('error.js', { runInNewContext, asBundle: true }, renderer => {
-      const stream = renderer.renderToStream()
-      stream.on('error', err => {
-        expect(err.stack).toContain('test/ssr/fixtures/error.js:1:6')
-        expect(err.message).toBe('foo')
-        done()
-      })
-    })
-  })
-
-  it('renderToString return Promise', done => {
-    createRenderer('app.js', { runInNewContext }, renderer => {
-      const context = { url: '/test' }
-      renderer.renderToString(context).then(res => {
-        expect(res).toBe('<div data-server-rendered="true">/test</div>')
-        expect(context.msg).toBe('hello')
-        done()
-      })
-    })
-  })
-
-  it('renderToString return Promise (error)', done => {
-    createRenderer('error.js', { runInNewContext }, renderer => {
-      renderer.renderToString().catch(err => {
-        expect(err.message).toBe('foo')
-        done()
-      })
-    })
-  })
-
-  it('renderToString return Promise (Promise rejection)', done => {
-    createRenderer('promise-rejection.js', { runInNewContext }, renderer => {
-      renderer.renderToString().catch(err => {
-        expect(err.message).toBe('foo')
-        done()
-      })
-    })
-  })
-}
diff --git a/1.Vue/test/ssr/ssr-stream.spec.js b/1.Vue/test/ssr/ssr-stream.spec.js
deleted file mode 100644
index 04e7965..0000000
--- a/1.Vue/test/ssr/ssr-stream.spec.js
+++ /dev/null
@@ -1,127 +0,0 @@
-import Vue from '../../dist/vue.runtime.common.js'
-import { createRenderer } from '../../packages/vue-server-renderer'
-const { renderToStream } = createRenderer()
-
-describe('SSR: renderToStream', () => {
-  it('should render to a stream', done => {
-    const stream = renderToStream(new Vue({
-      template: `
-        <div>
-          <p class="hi">yoyo</p>
-          <div id="ho" :class="[testClass, { red: isRed }]"></div>
-          <span>{{ test }}</span>
-          <input :value="test">
-          <b-comp></b-comp>
-          <c-comp></c-comp>
-        </div>
-      `,
-      data: {
-        test: 'hi',
-        isRed: true,
-        testClass: 'a'
-      },
-      components: {
-        bComp (resolve) {
-          return resolve({
-            render (h) {
-              return h('test-async-2')
-            },
-            components: {
-              testAsync2 (resolve) {
-                return resolve({
-                  created () { this.$parent.$parent.testClass = 'b' },
-                  render (h) {
-                    return h('div', { class: [this.$parent.$parent.testClass] }, 'test')
-                  }
-                })
-              }
-            }
-          })
-        },
-        cComp: {
-          render (h) {
-            return h('div', { class: [this.$parent.testClass] }, 'test')
-          }
-        }
-      }
-    }))
-    let res = ''
-    stream.on('data', chunk => {
-      res += chunk
-    })
-    stream.on('end', () => {
-      expect(res).toContain(
-        '<div data-server-rendered="true">' +
-          '<p class="hi">yoyo</p> ' +
-          '<div id="ho" class="a red"></div> ' +
-          '<span>hi</span> ' +
-          '<input value="hi"> ' +
-          '<div class="b">test</div> ' +
-          '<div class="b">test</div>' +
-        '</div>'
-      )
-      done()
-    })
-  })
-
-  it('should catch error', done => {
-    Vue.config.silent = true
-    const stream = renderToStream(new Vue({
-      render () {
-        throw new Error('oops')
-      }
-    }))
-    stream.on('error', err => {
-      expect(err.toString()).toMatch(/oops/)
-      Vue.config.silent = false
-      done()
-    })
-    stream.on('data', _ => _)
-  })
-
-  it('should not mingle two components', done => {
-    const padding = (new Array(20000)).join('x')
-    const component1 = new Vue({
-      template: `<div>${padding}<div></div></div>`,
-      _scopeId: '_component1'
-    })
-    const component2 = new Vue({
-      template: `<div></div>`,
-      _scopeId: '_component2'
-    })
-    const stream1 = renderToStream(component1)
-    const stream2 = renderToStream(component2)
-    let res = ''
-    stream1.on('data', (text) => {
-      res += text.toString('utf-8').replace(/x/g, '')
-    })
-    stream1.on('end', () => {
-      expect(res).not.toContain('_component2')
-      done()
-    })
-    stream1.read(1)
-    stream2.read(1)
-  })
-
-  it('should call context.rendered', done => {
-    let a = 0
-    const stream = renderToStream(new Vue({
-      template: `
-        <div>Hello</div>
-      `
-    }), {
-      rendered: () => {
-        a = 42
-      }
-    })
-    let res = ''
-    stream.on('data', chunk => {
-      res += chunk
-    })
-    stream.on('end', () => {
-      expect(res).toContain('<div data-server-rendered="true">Hello</div>')
-      expect(a).toBe(42)
-      done()
-    })
-  })
-})
diff --git a/1.Vue/test/ssr/ssr-string.spec.js b/1.Vue/test/ssr/ssr-string.spec.js
deleted file mode 100644
index e18ca2a..0000000
--- a/1.Vue/test/ssr/ssr-string.spec.js
+++ /dev/null
@@ -1,1604 +0,0 @@
-import Vue from '../../dist/vue.runtime.common.js'
-import VM from 'vm'
-import { createRenderer } from '../../packages/vue-server-renderer'
-const { renderToString } = createRenderer()
-
-describe('SSR: renderToString', () => {
-  it('static attributes', done => {
-    renderVmWithOptions({
-      template: '<div id="foo" bar="123"></div>'
-    }, result => {
-      expect(result).toContain('<div id="foo" bar="123" data-server-rendered="true"></div>')
-      done()
-    })
-  })
-
-  it('unary tags', done => {
-    renderVmWithOptions({
-      template: '<input value="123">'
-    }, result => {
-      expect(result).toContain('<input value="123" data-server-rendered="true">')
-      done()
-    })
-  })
-
-  it('dynamic attributes', done => {
-    renderVmWithOptions({
-      template: '<div qux="quux" :id="foo" :bar="baz"></div>',
-      data: {
-        foo: 'hi',
-        baz: 123
-      }
-    }, result => {
-      expect(result).toContain('<div qux="quux" id="hi" bar="123" data-server-rendered="true"></div>')
-      done()
-    })
-  })
-
-  it('static class', done => {
-    renderVmWithOptions({
-      template: '<div class="foo bar"></div>'
-    }, result => {
-      expect(result).toContain('<div data-server-rendered="true" class="foo bar"></div>')
-      done()
-    })
-  })
-
-  it('dynamic class', done => {
-    renderVmWithOptions({
-      template: '<div class="foo bar" :class="[a, { qux: hasQux, quux: hasQuux }]"></div>',
-      data: {
-        a: 'baz',
-        hasQux: true,
-        hasQuux: false
-      }
-    }, result => {
-      expect(result).toContain('<div data-server-rendered="true" class="foo bar baz qux"></div>')
-      done()
-    })
-  })
-
-  it('custom component class', done => {
-    renderVmWithOptions({
-      template: '<div><cmp class="cmp"></cmp></div>',
-      components: {
-        cmp: {
-          render: h => h('div', 'test')
-        }
-      }
-    }, result => {
-      expect(result).toContain('<div data-server-rendered="true"><div class="cmp">test</div></div>')
-      done()
-    })
-  })
-
-  it('nested component class', done => {
-    renderVmWithOptions({
-      template: '<cmp class="outer" :class="cls"></cmp>',
-      data: { cls: { 'success': 1 }},
-      components: {
-        cmp: {
-          render: h => h('div', [h('nested', { staticClass: 'nested', 'class': { 'error': 1 }})]),
-          components: {
-            nested: {
-              render: h => h('div', { staticClass: 'inner' }, 'test')
-            }
-          }
-        }
-      }
-    }, result => {
-      expect(result).toContain('<div data-server-rendered="true" class="outer success">' +
-          '<div class="inner nested error">test</div>' +
-        '</div>')
-      done()
-    })
-  })
-
-  it('dynamic style', done => {
-    renderVmWithOptions({
-      template: '<div style="background-color:black" :style="{ fontSize: fontSize + \'px\', color: color }"></div>',
-      data: {
-        fontSize: 14,
-        color: 'red'
-      }
-    }, result => {
-      expect(result).toContain(
-        '<div data-server-rendered="true" style="background-color:black;font-size:14px;color:red;"></div>'
-      )
-      done()
-    })
-  })
-
-  it('dynamic string style', done => {
-    renderVmWithOptions({
-      template: '<div :style="style"></div>',
-      data: {
-        style: 'color:red'
-      }
-    }, result => {
-      expect(result).toContain(
-        '<div data-server-rendered="true" style="color:red;"></div>'
-      )
-      done()
-    })
-  })
-
-  it('auto-prefixed style value as array', done => {
-    renderVmWithOptions({
-      template: '<div :style="style"></div>',
-      data: {
-        style: {
-          display: ['-webkit-box', '-ms-flexbox', 'flex']
-        }
-      }
-    }, result => {
-      expect(result).toContain(
-        '<div data-server-rendered="true" style="display:-webkit-box;display:-ms-flexbox;display:flex;"></div>'
-      )
-      done()
-    })
-  })
-
-  it('custom component style', done => {
-    renderVmWithOptions({
-      template: '<section><comp :style="style"></comp></section>',
-      data: {
-        style: 'color:red'
-      },
-      components: {
-        comp: {
-          template: '<div></div>'
-        }
-      }
-    }, result => {
-      expect(result).toContain(
-        '<section data-server-rendered="true"><div style="color:red;"></div></section>'
-      )
-      done()
-    })
-  })
-
-  it('nested custom component style', done => {
-    renderVmWithOptions({
-      template: '<comp style="color: blue" :style="style"></comp>',
-      data: {
-        style: 'color:red'
-      },
-      components: {
-        comp: {
-          template: '<nested style="text-align: left;" :style="{fontSize:\'520rem\'}"></nested>',
-          components: {
-            nested: {
-              template: '<div></div>'
-            }
-          }
-        }
-      }
-    }, result => {
-      expect(result).toContain(
-        '<div data-server-rendered="true" style="text-align:left;font-size:520rem;color:red;"></div>'
-      )
-      done()
-    })
-  })
-
-  it('component style not passed to child', done => {
-    renderVmWithOptions({
-      template: '<comp :style="style"></comp>',
-      data: {
-        style: 'color:red'
-      },
-      components: {
-        comp: {
-          template: '<div><div></div></div>'
-        }
-      }
-    }, result => {
-      expect(result).toContain(
-        '<div data-server-rendered="true" style="color:red;"><div></div></div>'
-      )
-      done()
-    })
-  })
-
-  it('component style not passed to slot', done => {
-    renderVmWithOptions({
-      template: '<comp :style="style"><span style="color:black"></span></comp>',
-      data: {
-        style: 'color:red'
-      },
-      components: {
-        comp: {
-          template: '<div><slot></slot></div>'
-        }
-      }
-    }, result => {
-      expect(result).toContain(
-        '<div data-server-rendered="true" style="color:red;"><span style="color:black;"></span></div>'
-      )
-      done()
-    })
-  })
-
-  it('attrs merging on components', done => {
-    const Test = {
-      render: h => h('div', {
-        attrs: { id: 'a' }
-      })
-    }
-    renderVmWithOptions({
-      render: h => h(Test, {
-        attrs: { id: 'b', name: 'c' }
-      })
-    }, res => {
-      expect(res).toContain(
-        '<div id="b" data-server-rendered="true" name="c"></div>'
-      )
-      done()
-    })
-  })
-
-  it('domProps merging on components', done => {
-    const Test = {
-      render: h => h('div', {
-        domProps: { innerHTML: 'a' }
-      })
-    }
-    renderVmWithOptions({
-      render: h => h(Test, {
-        domProps: { innerHTML: 'b', value: 'c' }
-      })
-    }, res => {
-      expect(res).toContain(
-        '<div data-server-rendered="true" value="c">b</div>'
-      )
-      done()
-    })
-  })
-
-  it('v-show directive render', done => {
-    renderVmWithOptions({
-      template: '<div v-show="false"><span>inner</span></div>'
-    }, res => {
-      expect(res).toContain(
-        '<div data-server-rendered="true" style="display:none;"><span>inner</span></div>'
-      )
-      done()
-    })
-  })
-
-  it('v-show directive merge with style', done => {
-    renderVmWithOptions({
-      template: '<div :style="[{lineHeight: 1}]" v-show="false"><span>inner</span></div>'
-    }, res => {
-      expect(res).toContain(
-        '<div data-server-rendered="true" style="line-height:1;display:none;"><span>inner</span></div>'
-      )
-      done()
-    })
-  })
-
-  it('v-show directive not passed to child', done => {
-    renderVmWithOptions({
-      template: '<foo v-show="false"></foo>',
-      components: {
-        foo: {
-          template: '<div><span>inner</span></div>'
-        }
-      }
-    }, res => {
-      expect(res).toContain(
-        '<div data-server-rendered="true" style="display:none;"><span>inner</span></div>'
-      )
-      done()
-    })
-  })
-
-  it('v-show directive not passed to slot', done => {
-    renderVmWithOptions({
-      template: '<foo v-show="false"><span>inner</span></foo>',
-      components: {
-        foo: {
-          template: '<div><slot></slot></div>'
-        }
-      }
-    }, res => {
-      expect(res).toContain(
-        '<div data-server-rendered="true" style="display:none;"><span>inner</span></div>'
-      )
-      done()
-    })
-  })
-
-  it('v-show directive merging on components', done => {
-    renderVmWithOptions({
-      template: '<foo v-show="false"></foo>',
-      components: {
-        foo: {
-          render: h => h('bar', {
-            directives: [{
-              name: 'show',
-              value: true
-            }]
-          }),
-          components: {
-            bar: {
-              render: h => h('div', 'inner')
-            }
-          }
-        }
-      }
-    }, res => {
-      expect(res).toContain(
-        '<div data-server-rendered="true" style="display:none;">inner</div>'
-      )
-      done()
-    })
-  })
-
-  it('text interpolation', done => {
-    renderVmWithOptions({
-      template: '<div>{{ foo }} side {{ bar }}</div>',
-      data: {
-        foo: 'server',
-        bar: '<span>rendering</span>'
-      }
-    }, result => {
-      expect(result).toContain('<div data-server-rendered="true">server side &lt;span&gt;rendering&lt;/span&gt;</div>')
-      done()
-    })
-  })
-
-  it('v-html on root', done => {
-    renderVmWithOptions({
-      template: '<div v-html="text"></div>',
-      data: {
-        text: '<span>foo</span>'
-      }
-    }, result => {
-      expect(result).toContain('<div data-server-rendered="true"><span>foo</span></div>')
-      done()
-    })
-  })
-
-  it('v-text on root', done => {
-    renderVmWithOptions({
-      template: '<div v-text="text"></div>',
-      data: {
-        text: '<span>foo</span>'
-      }
-    }, result => {
-      expect(result).toContain('<div data-server-rendered="true">&lt;span&gt;foo&lt;/span&gt;</div>')
-      done()
-    })
-  })
-
-  it('v-html', done => {
-    renderVmWithOptions({
-      template: '<div><div v-html="text"></div></div>',
-      data: {
-        text: '<span>foo</span>'
-      }
-    }, result => {
-      expect(result).toContain('<div data-server-rendered="true"><div><span>foo</span></div></div>')
-      done()
-    })
-  })
-
-  it('v-html with null value', done => {
-    renderVmWithOptions({
-      template: '<div><div v-html="text"></div></div>',
-      data: {
-        text: null
-      }
-    }, result => {
-      expect(result).toContain('<div data-server-rendered="true"><div></div></div>')
-      done()
-    })
-  })
-
-  it('v-text', done => {
-    renderVmWithOptions({
-      template: '<div><div v-text="text"></div></div>',
-      data: {
-        text: '<span>foo</span>'
-      }
-    }, result => {
-      expect(result).toContain('<div data-server-rendered="true"><div>&lt;span&gt;foo&lt;/span&gt;</div></div>')
-      done()
-    })
-  })
-
-  it('v-text with null value', done => {
-    renderVmWithOptions({
-      template: '<div><div v-text="text"></div></div>',
-      data: {
-        text: null
-      }
-    }, result => {
-      expect(result).toContain('<div data-server-rendered="true"><div></div></div>')
-      done()
-    })
-  })
-
-  it('child component (hoc)', done => {
-    renderVmWithOptions({
-      template: '<child class="foo" :msg="msg"></child>',
-      data: {
-        msg: 'hello'
-      },
-      components: {
-        child: {
-          props: ['msg'],
-          data () {
-            return { name: 'bar' }
-          },
-          render () {
-            const h = this.$createElement
-            return h('div', { class: ['bar'] }, [`${this.msg} ${this.name}`])
-          }
-        }
-      }
-    }, result => {
-      expect(result).toContain('<div data-server-rendered="true" class="foo bar">hello bar</div>')
-      done()
-    })
-  })
-
-  it('has correct lifecycle during render', done => {
-    let lifecycleCount = 1
-    renderVmWithOptions({
-      template: '<div><span>{{ val }}</span><test></test></div>',
-      data: {
-        val: 'hi'
-      },
-      beforeCreate () {
-        expect(lifecycleCount++).toBe(1)
-      },
-      created () {
-        this.val = 'hello'
-        expect(this.val).toBe('hello')
-        expect(lifecycleCount++).toBe(2)
-      },
-      components: {
-        test: {
-          beforeCreate () {
-            expect(lifecycleCount++).toBe(3)
-          },
-          created () {
-            expect(lifecycleCount++).toBe(4)
-          },
-          render () {
-            expect(lifecycleCount++).toBeGreaterThan(4)
-            return this.$createElement('span', { class: ['b'] }, 'testAsync')
-          }
-        }
-      }
-    }, result => {
-      expect(result).toContain(
-        '<div data-server-rendered="true">' +
-          '<span>hello</span>' +
-          '<span class="b">testAsync</span>' +
-        '</div>'
-      )
-      done()
-    })
-  })
-
-  it('computed properties', done => {
-    renderVmWithOptions({
-      template: '<div>{{ b }}</div>',
-      data: {
-        a: {
-          b: 1
-        }
-      },
-      computed: {
-        b () {
-          return this.a.b + 1
-        }
-      },
-      created () {
-        this.a.b = 2
-        expect(this.b).toBe(3)
-      }
-    }, result => {
-      expect(result).toContain('<div data-server-rendered="true">3</div>')
-      done()
-    })
-  })
-
-  it('renders async component', done => {
-    renderVmWithOptions({
-      template: `
-        <div>
-          <test-async></test-async>
-        </div>
-      `,
-      components: {
-        testAsync (resolve) {
-          setTimeout(() => resolve({
-            render () {
-              return this.$createElement('span', { class: ['b'] }, 'testAsync')
-            }
-          }), 1)
-        }
-      }
-    }, result => {
-      expect(result).toContain('<div data-server-rendered="true"><span class="b">testAsync</span></div>')
-      done()
-    })
-  })
-
-  it('renders async component (Promise, nested)', done => {
-    const Foo = () => Promise.resolve({
-      render: h => h('div', [h('span', 'foo'), h(Bar)])
-    })
-    const Bar = () => ({
-      component: Promise.resolve({
-        render: h => h('span', 'bar')
-      })
-    })
-    renderVmWithOptions({
-      render: h => h(Foo)
-    }, res => {
-      expect(res).toContain(`<div data-server-rendered="true"><span>foo</span><span>bar</span></div>`)
-      done()
-    })
-  })
-
-  it('renders async component (ES module)', done => {
-    const Foo = () => Promise.resolve({
-      __esModule: true,
-      default: {
-        render: h => h('div', [h('span', 'foo'), h(Bar)])
-      }
-    })
-    const Bar = () => ({
-      component: Promise.resolve({
-        __esModule: true,
-        default: {
-          render: h => h('span', 'bar')
-        }
-      })
-    })
-    renderVmWithOptions({
-      render: h => h(Foo)
-    }, res => {
-      expect(res).toContain(`<div data-server-rendered="true"><span>foo</span><span>bar</span></div>`)
-      done()
-    })
-  })
-
-  it('renders async component (hoc)', done => {
-    renderVmWithOptions({
-      template: '<test-async></test-async>',
-      components: {
-        testAsync: () => Promise.resolve({
-          render () {
-            return this.$createElement('span', { class: ['b'] }, 'testAsync')
-          }
-        })
-      }
-    }, result => {
-      expect(result).toContain('<span data-server-rendered="true" class="b">testAsync</span>')
-      done()
-    })
-  })
-
-  it('renders async component (functional, single node)', done => {
-    renderVmWithOptions({
-      template: `
-        <div>
-          <test-async></test-async>
-        </div>
-      `,
-      components: {
-        testAsync (resolve) {
-          setTimeout(() => resolve({
-            functional: true,
-            render (h) {
-              return h('span', { class: ['b'] }, 'testAsync')
-            }
-          }), 1)
-        }
-      }
-    }, result => {
-      expect(result).toContain('<div data-server-rendered="true"><span class="b">testAsync</span></div>')
-      done()
-    })
-  })
-
-  it('renders async component (functional, multiple nodes)', done => {
-    renderVmWithOptions({
-      template: `
-        <div>
-          <test-async></test-async>
-        </div>
-      `,
-      components: {
-        testAsync (resolve) {
-          setTimeout(() => resolve({
-            functional: true,
-            render (h) {
-              return [
-                h('span', { class: ['a'] }, 'foo'),
-                h('span', { class: ['b'] }, 'bar')
-              ]
-            }
-          }), 1)
-        }
-      }
-    }, result => {
-      expect(result).toContain(
-        '<div data-server-rendered="true">' +
-          '<span class="a">foo</span>' +
-          '<span class="b">bar</span>' +
-        '</div>'
-      )
-      done()
-    })
-  })
-
-  it('renders nested async functional component', done => {
-    renderVmWithOptions({
-      template: `
-        <div>
-          <outer-async></outer-async>
-        </div>
-      `,
-      components: {
-        outerAsync (resolve) {
-          setTimeout(() => resolve({
-            functional: true,
-            render (h) {
-              return h('innerAsync')
-            }
-          }), 1)
-        },
-        innerAsync (resolve) {
-          setTimeout(() => resolve({
-            functional: true,
-            render (h) {
-              return h('span', { class: ['a'] }, 'inner')
-            },
-          }), 1)
-        }
-      }
-    }, result => {
-      expect(result).toContain(
-        '<div data-server-rendered="true">' +
-          '<span class="a">inner</span>' +
-        '</div>'
-      )
-      done()
-    })
-  })
-
-  it('should catch async component error', done => {
-    Vue.config.silent = true
-    renderToString(new Vue({
-      template: '<test-async></test-async>',
-      components: {
-        testAsync: () => Promise.resolve({
-          render () {
-            throw new Error('foo')
-          }
-        })
-      }
-    }), (err, result) => {
-      Vue.config.silent = false
-      expect(err).toBeTruthy()
-      expect(result).toBeUndefined()
-      done()
-    })
-  })
-
-  it('everything together', done => {
-    renderVmWithOptions({
-      template: `
-        <div>
-          <p class="hi">yoyo</p>
-          <div id="ho" :class="{ red: isRed }"></div>
-          <span>{{ test }}</span>
-          <input :value="test">
-          <img :src="imageUrl">
-          <test></test>
-          <test-async></test-async>
-        </div>
-      `,
-      data: {
-        test: 'hi',
-        isRed: true,
-        imageUrl: 'https://vuejs.org/images/logo.png'
-      },
-      components: {
-        test: {
-          render () {
-            return this.$createElement('div', { class: ['a'] }, 'test')
-          }
-        },
-        testAsync (resolve) {
-          resolve({
-            render () {
-              return this.$createElement('span', { class: ['b'] }, 'testAsync')
-            }
-          })
-        }
-      }
-    }, result => {
-      expect(result).toContain(
-        '<div data-server-rendered="true">' +
-          '<p class="hi">yoyo</p> ' +
-          '<div id="ho" class="red"></div> ' +
-          '<span>hi</span> ' +
-          '<input value="hi"> ' +
-          '<img src="https://vuejs.org/images/logo.png"> ' +
-          '<div class="a">test</div> ' +
-          '<span class="b">testAsync</span>' +
-        '</div>'
-      )
-      done()
-    })
-  })
-
-  it('normal attr', done => {
-    renderVmWithOptions({
-      template: `
-        <div>
-          <span :test="'ok'">hello</span>
-          <span :test="null">hello</span>
-          <span :test="false">hello</span>
-          <span :test="true">hello</span>
-          <span :test="0">hello</span>
-        </div>
-      `
-    }, result => {
-      expect(result).toContain(
-        '<div data-server-rendered="true">' +
-          '<span test="ok">hello</span> ' +
-          '<span>hello</span> ' +
-          '<span>hello</span> ' +
-          '<span test="true">hello</span> ' +
-          '<span test="0">hello</span>' +
-        '</div>'
-      )
-      done()
-    })
-  })
-
-  it('enumerated attr', done => {
-    renderVmWithOptions({
-      template: `
-        <div>
-          <span :draggable="true">hello</span>
-          <span :draggable="'ok'">hello</span>
-          <span :draggable="null">hello</span>
-          <span :draggable="false">hello</span>
-          <span :draggable="''">hello</span>
-          <span :draggable="'false'">hello</span>
-        </div>
-      `
-    }, result => {
-      expect(result).toContain(
-        '<div data-server-rendered="true">' +
-          '<span draggable="true">hello</span> ' +
-          '<span draggable="true">hello</span> ' +
-          '<span draggable="false">hello</span> ' +
-          '<span draggable="false">hello</span> ' +
-          '<span draggable="true">hello</span> ' +
-          '<span draggable="false">hello</span>' +
-        '</div>'
-      )
-      done()
-    })
-  })
-
-  it('boolean attr', done => {
-    renderVmWithOptions({
-      template: `
-        <div>
-          <span :disabled="true">hello</span>
-          <span :disabled="'ok'">hello</span>
-          <span :disabled="null">hello</span>
-          <span :disabled="''">hello</span>
-        </div>
-      `
-    }, result => {
-      expect(result).toContain(
-        '<div data-server-rendered="true">' +
-          '<span disabled="disabled">hello</span> ' +
-          '<span disabled="disabled">hello</span> ' +
-          '<span>hello</span> ' +
-          '<span disabled="disabled">hello</span>' +
-        '</div>'
-      )
-      done()
-    })
-  })
-
-  it('v-bind object', done => {
-    renderVmWithOptions({
-      data: {
-        test: { id: 'a', class: ['a', 'b'], value: 'c' }
-      },
-      template: '<input v-bind="test">'
-    }, result => {
-      expect(result).toContain('<input id="a" data-server-rendered="true" value="c" class="a b">')
-      done()
-    })
-  })
-
-  it('custom directives', done => {
-    const renderer = createRenderer({
-      directives: {
-        'class-prefixer': (node, dir) => {
-          if (node.data.class) {
-            node.data.class = `${dir.value}-${node.data.class}`
-          }
-          if (node.data.staticClass) {
-            node.data.staticClass = `${dir.value}-${node.data.staticClass}`
-          }
-        }
-      }
-    })
-    renderer.renderToString(new Vue({
-      render () {
-        const h = this.$createElement
-        return h('p', {
-          class: 'class1',
-          staticClass: 'class2',
-          directives: [{
-            name: 'class-prefixer',
-            value: 'my'
-          }]
-        }, ['hello world'])
-      }
-    }), (err, result) => {
-      expect(err).toBeNull()
-      expect(result).toContain('<p data-server-rendered="true" class="my-class2 my-class1">hello world</p>')
-      done()
-    })
-  })
-
-  it('should not warn for custom directives that do not have server-side implementation', done => {
-    renderToString(new Vue({
-      directives: {
-        test: {
-          bind() {
-            // noop
-          }
-        }
-      },
-      template: '<div v-test></div>',
-    }), () => {
-      expect('Failed to resolve directive: test').not.toHaveBeenWarned()
-      done()
-    })
-  })
-
-  it('_scopeId', done => {
-    renderVmWithOptions({
-      _scopeId: '_v-parent',
-      template: '<div id="foo"><p><child></child></p></div>',
-      components: {
-        child: {
-          _scopeId: '_v-child',
-          render () {
-            const h = this.$createElement
-            return h('div', null, [h('span', null, ['foo'])])
-          }
-        }
-      }
-    }, result => {
-      expect(result).toContain(
-        '<div id="foo" data-server-rendered="true" _v-parent>' +
-          '<p _v-parent>' +
-            '<div _v-child _v-parent><span _v-child>foo</span></div>' +
-          '</p>' +
-        '</div>'
-      )
-      done()
-    })
-  })
-
-  it('_scopeId on slot content', done => {
-    renderVmWithOptions({
-      _scopeId: '_v-parent',
-      template: '<div><child><p>foo</p></child></div>',
-      components: {
-        child: {
-          _scopeId: '_v-child',
-          render () {
-            const h = this.$createElement
-            return h('div', null, this.$slots.default)
-          }
-        }
-      }
-    }, result => {
-      expect(result).toContain(
-        '<div data-server-rendered="true" _v-parent>' +
-          '<div _v-child _v-parent><p _v-child _v-parent>foo</p></div>' +
-        '</div>'
-      )
-      done()
-    })
-  })
-
-  it('comment nodes', done => {
-    renderVmWithOptions({
-      template: '<div><transition><div v-if="false"></div></transition></div>'
-    }, result => {
-      expect(result).toContain(`<div data-server-rendered="true"><!----></div>`)
-      done()
-    })
-  })
-
-  it('should catch error', done => {
-    Vue.config.silent = true
-    renderToString(new Vue({
-      render () {
-        throw new Error('oops')
-      }
-    }), err => {
-      expect(err instanceof Error).toBe(true)
-      Vue.config.silent = false
-      done()
-    })
-  })
-
-  it('default value Foreign Function', () => {
-    const FunctionConstructor = VM.runInNewContext('Function')
-    const func = () => 123
-    const vm = new Vue({
-      props: {
-        a: {
-          type: FunctionConstructor,
-          default: func
-        }
-      },
-      propsData: {
-        a: undefined
-      }
-    })
-    expect(vm.a).toBe(func)
-  })
-
-  it('should prevent xss in attributes', done => {
-    renderVmWithOptions({
-      data: {
-        xss: '"><script>alert(1)</script>'
-      },
-      template: `
-        <div>
-          <a :title="xss" :style="{ color: xss }" :class="[xss]">foo</a>
-        </div>
-      `
-    }, res => {
-      expect(res).not.toContain(`<script>alert(1)</script>`)
-      done()
-    })
-  })
-
-  it('should prevent xss in attribute names', done => {
-    renderVmWithOptions({
-      data: {
-        xss: {
-          'foo="bar"></div><script>alert(1)</script>': ''
-        }
-      },
-      template: `
-        <div v-bind="xss"></div>
-      `
-    }, res => {
-      expect(res).not.toContain(`<script>alert(1)</script>`)
-      done()
-    })
-  })
-
-  it('should prevent xss in attribute names (optimized)', done => {
-    renderVmWithOptions({
-      data: {
-        xss: {
-          'foo="bar"></div><script>alert(1)</script>': ''
-        }
-      },
-      template: `
-        <div>
-          <a v-bind="xss">foo</a>
-        </div>
-      `
-    }, res => {
-      expect(res).not.toContain(`<script>alert(1)</script>`)
-      done()
-    })
-  })
-
-  it('should prevent script xss with v-bind object syntax + array value', done => {
-    renderVmWithOptions({
-      data: {
-        test: ['"><script>alert(1)</script><!--"']
-      },
-      template: `<div v-bind="{ test }"></div>`
-    }, res => {
-      expect(res).not.toContain(`<script>alert(1)</script>`)
-      done()
-    })
-  })
-
-  it('v-if', done => {
-    renderVmWithOptions({
-      template: `
-        <div>
-          <span v-if="true">foo</span>
-          <span v-if="false">bar</span>
-        </div>
-      `
-    }, res => {
-      expect(res).toContain(`<div data-server-rendered="true"><span>foo</span> <!----></div>`)
-      done()
-    })
-  })
-
-  it('v-for', done => {
-    renderVmWithOptions({
-      template: `
-        <div>
-          <span>foo</span>
-          <span v-for="i in 2">{{ i }}</span>
-        </div>
-      `
-    }, res => {
-      expect(res).toContain(`<div data-server-rendered="true"><span>foo</span> <span>1</span><span>2</span></div>`)
-      done()
-    })
-  })
-
-  it('template v-if', done => {
-    renderVmWithOptions({
-      template: `
-        <div>
-          <span>foo</span>
-          <template v-if="true">
-            <span>foo</span> bar <span>baz</span>
-          </template>
-        </div>
-      `
-    }, res => {
-      expect(res).toContain(`<div data-server-rendered="true"><span>foo</span> <span>foo</span> bar <span>baz</span></div>`)
-      done()
-    })
-  })
-
-  it('template v-for', done => {
-    renderVmWithOptions({
-      template: `
-        <div>
-          <span>foo</span>
-          <template v-for="i in 2">
-            <span>{{ i }}</span><span>bar</span>
-          </template>
-        </div>
-      `
-    }, res => {
-      expect(res).toContain(`<div data-server-rendered="true"><span>foo</span> <span>1</span><span>bar</span><span>2</span><span>bar</span></div>`)
-      done()
-    })
-  })
-
-  it('with inheritAttrs: false + $attrs', done => {
-    renderVmWithOptions({
-      template: `<foo id="a"/>`,
-      components: {
-        foo: {
-          inheritAttrs: false,
-          template: `<div><div v-bind="$attrs"></div></div>`
-        }
-      }
-    }, res => {
-      expect(res).toBe(`<div data-server-rendered="true"><div id="a"></div></div>`)
-      done()
-    })
-  })
-
-  it('should escape static strings', done => {
-    renderVmWithOptions({
-      template: `<div>&lt;foo&gt;</div>`
-    }, res => {
-      expect(res).toBe(`<div data-server-rendered="true">&lt;foo&gt;</div>`)
-      done()
-    })
-  })
-
-  it('should not cache computed properties', done => {
-    renderVmWithOptions({
-      template: `<div>{{ foo }}</div>`,
-      data: () => ({ bar: 1 }),
-      computed: {
-        foo () { return this.bar + 1 }
-      },
-      created () {
-        this.foo // access
-        this.bar++ // trigger change
-      }
-    }, res => {
-      expect(res).toBe(`<div data-server-rendered="true">3</div>`)
-      done()
-    })
-  })
-
-  // #8977
-  it('should call computed properties with vm as first argument', done => {
-    renderToString(new Vue({
-      data: {
-        firstName: 'Evan',
-        lastName: 'You'
-      },
-      computed: {
-        fullName: ({ firstName, lastName }) => `${firstName} ${lastName}`,
-      },
-      template: '<div>{{ fullName }}</div>',
-    }), (err, result) => {
-      expect(err).toBeNull()
-      expect(result).toContain('<div data-server-rendered="true">Evan You</div>')
-      done()
-    })
-  })
-
-  it('return Promise', done => {
-    renderToString(new Vue({
-      template: `<div>{{ foo }}</div>`,
-      data: { foo: 'bar' }
-    })).then(res => {
-      expect(res).toBe(`<div data-server-rendered="true">bar</div>`)
-      done()
-    })
-  })
-
-  it('return Promise (error)', done => {
-    Vue.config.silent = true
-    renderToString(new Vue({
-      render () {
-        throw new Error('foobar')
-      }
-    })).catch(err => {
-      expect(err.toString()).toContain(`foobar`)
-      Vue.config.silent = false
-      done()
-    })
-  })
-
-  it('should catch template compilation error', done => {
-    renderToString(new Vue({
-      template: `<div></div><div></div>`
-    }), (err) => {
-      expect(err.toString()).toContain('Component template should contain exactly one root element')
-      done()
-    })
-  })
-
-  // #6907
-  it('should not optimize root if conditions', done => {
-    renderVmWithOptions({
-      data: { foo: 123 },
-      template: `<input :type="'text'" v-model="foo">`
-    }, res => {
-      expect(res).toBe(`<input type="text" data-server-rendered="true" value="123">`)
-      done()
-    })
-  })
-
-  it('render muted properly', done => {
-    renderVmWithOptions({
-      template: '<video muted></video>'
-    }, result => {
-      expect(result).toContain('<video muted="muted" data-server-rendered="true"></video>')
-      done()
-    })
-  })
-
-  it('render v-model with textarea', done => {
-    renderVmWithOptions({
-      data: { foo: 'bar' },
-      template: '<div><textarea v-model="foo"></textarea></div>'
-    }, result => {
-      expect(result).toContain('<textarea>bar</textarea>')
-      done()
-    })
-  })
-
-  it('render v-model with textarea (non-optimized)', done => {
-    renderVmWithOptions({
-      render (h) {
-        return h('textarea', {
-          domProps: {
-            value: 'foo'
-          }
-        })
-      }
-    }, result => {
-      expect(result).toContain('<textarea data-server-rendered="true">foo</textarea>')
-      done()
-    })
-  })
-
-  it('render v-model with <select> (value binding)', done => {
-    renderVmWithOptions({
-      data: {
-        selected: 2,
-        options: [
-          { id: 1, label: 'one' },
-          { id: 2, label: 'two' }
-        ]
-      },
-      template: `
-      <div>
-        <select v-model="selected">
-          <option v-for="o in options" :value="o.id">{{ o.label }}</option>
-        </select>
-      </div>
-      `
-    }, result => {
-      expect(result).toContain(
-        '<select>' +
-          '<option value="1">one</option>' +
-          '<option selected="selected" value="2">two</option>' +
-        '</select>'
-      )
-      done()
-    })
-  })
-
-  it('render v-model with <select> (static value)', done => {
-    renderVmWithOptions({
-      data: {
-        selected: 2
-      },
-      template: `
-      <div>
-        <select v-model="selected">
-          <option value="1">one</option>
-          <option value="2">two</option>
-        </select>
-      </div>
-      `
-    }, result => {
-      expect(result).toContain(
-        '<select>' +
-          '<option value="1">one</option> ' +
-          '<option value="2" selected="selected">two</option>' +
-        '</select>'
-      )
-      done()
-    })
-  })
-
-  it('render v-model with <select> (text as value)', done => {
-    renderVmWithOptions({
-      data: {
-        selected: 2,
-        options: [
-          { id: 1, label: 'one' },
-          { id: 2, label: 'two' }
-        ]
-      },
-      template: `
-      <div>
-        <select v-model="selected">
-          <option v-for="o in options">{{ o.id }}</option>
-        </select>
-      </div>
-      `
-    }, result => {
-      expect(result).toContain(
-        '<select>' +
-          '<option>1</option>' +
-          '<option selected="selected">2</option>' +
-        '</select>'
-      )
-      done()
-    })
-  })
-
-  // #7223
-  it('should not double escape attribute values', done => {
-    renderVmWithOptions({
-      template: `
-      <div>
-        <div id="a\nb"></div>
-      </div>
-      `
-    }, result => {
-      expect(result).toContain(`<div id="a\nb"></div>`)
-      done()
-    })
-  })
-
-  // #7859
-  it('should not double escape class values', done => {
-    renderVmWithOptions({
-      template: `
-      <div>
-        <div class="a\nb"></div>
-      </div>
-      `
-    }, result => {
-      expect(result).toContain(`<div class="a\nb"></div>`)
-      done()
-    })
-  })
-
-  it('should expose ssr helpers on functional context', done => {
-    let called = false
-    renderVmWithOptions({
-      template: `<div><foo/></div>`,
-      components: {
-        foo: {
-          functional: true,
-          render (h, ctx) {
-            expect(ctx._ssrNode).toBeTruthy()
-            called = true
-          }
-        }
-      }
-    }, () => {
-      expect(called).toBe(true)
-      done()
-    })
-  })
-
-  it('should support serverPrefetch option', done => {
-    renderVmWithOptions({
-      template: `
-        <div>{{ count }}</div>
-      `,
-      data: {
-        count: 0
-      },
-      serverPrefetch () {
-        return new Promise((resolve) => {
-          setTimeout(() => {
-            this.count = 42
-            resolve()
-          }, 1)
-        })
-      }
-    }, result => {
-      expect(result).toContain('<div data-server-rendered="true">42</div>')
-      done()
-    })
-  })
-
-  it('should support serverPrefetch option (nested)', done => {
-    renderVmWithOptions({
-      template: `
-        <div>
-          <span>{{ count }}</span>
-          <nested-prefetch></nested-prefetch>
-        </div>
-      `,
-      data: {
-        count: 0
-      },
-      serverPrefetch () {
-        return new Promise((resolve) => {
-          setTimeout(() => {
-            this.count = 42
-            resolve()
-          }, 1)
-        })
-      },
-      components: {
-        nestedPrefetch: {
-          template: `
-            <div>{{ message }}</div>
-          `,
-          data () {
-            return {
-              message: ''
-            }
-          },
-          serverPrefetch () {
-            return new Promise((resolve) => {
-              setTimeout(() => {
-                this.message = 'vue.js'
-                resolve()
-              }, 1)
-            })
-          }
-        }
-      }
-    }, result => {
-      expect(result).toContain('<div data-server-rendered="true"><span>42</span> <div>vue.js</div></div>')
-      done()
-    })
-  })
-
-  it('should support serverPrefetch option (nested async)', done => {
-    renderVmWithOptions({
-      template: `
-        <div>
-          <span>{{ count }}</span>
-          <nested-prefetch></nested-prefetch>
-        </div>
-      `,
-      data: {
-        count: 0
-      },
-      serverPrefetch () {
-        return new Promise((resolve) => {
-          setTimeout(() => {
-            this.count = 42
-            resolve()
-          }, 1)
-        })
-      },
-      components: {
-        nestedPrefetch (resolve) {
-          resolve({
-            template: `
-              <div>{{ message }}</div>
-            `,
-            data () {
-              return {
-                message: ''
-              }
-            },
-            serverPrefetch () {
-              return new Promise((resolve) => {
-                setTimeout(() => {
-                  this.message = 'vue.js'
-                  resolve()
-                }, 1)
-              })
-            }
-          })
-        }
-      }
-    }, result => {
-      expect(result).toContain('<div data-server-rendered="true"><span>42</span> <div>vue.js</div></div>')
-      done()
-    })
-  })
-
-  it('should merge serverPrefetch option', done => {
-    const mixin = {
-      data: {
-        message: ''
-      },
-      serverPrefetch () {
-        return new Promise((resolve) => {
-          setTimeout(() => {
-            this.message = 'vue.js'
-            resolve()
-          }, 1)
-        })
-      }
-    }
-    renderVmWithOptions({
-      mixins: [mixin],
-      template: `
-        <div>
-          <span>{{ count }}</span>
-          <div>{{ message }}</div>
-        </div>
-      `,
-      data: {
-        count: 0
-      },
-      serverPrefetch () {
-        return new Promise((resolve) => {
-          setTimeout(() => {
-            this.count = 42
-            resolve()
-          }, 1)
-        })
-      }
-    }, result => {
-      expect(result).toContain('<div data-server-rendered="true"><span>42</span> <div>vue.js</div></div>')
-      done()
-    })
-  })
-
-  it(`should skip serverPrefetch option that doesn't return a promise`, done => {
-    renderVmWithOptions({
-      template: `
-        <div>{{ count }}</div>
-      `,
-      data: {
-        count: 0
-      },
-      serverPrefetch () {
-        setTimeout(() => {
-          this.count = 42
-        }, 1)
-      }
-    }, result => {
-      expect(result).toContain('<div data-server-rendered="true">0</div>')
-      done()
-    })
-  })
-
-  it('should call context.rendered', done => {
-    let a = 0
-    renderToString(new Vue({
-      template: '<div>Hello</div>'
-    }), {
-      rendered: () => {
-        a = 42
-      }
-    }, (err, res) => {
-      expect(err).toBeNull()
-      expect(res).toContain('<div data-server-rendered="true">Hello</div>')
-      expect(a).toBe(42)
-      done()
-    })
-  })
-
-  it('invalid style value', done => {
-    renderVmWithOptions({
-      template: '<div :style="style"><p :style="style2"/></div>',
-      data: {
-        // all invalid, should not even have "style" attribute
-        style: {
-          opacity: {},
-          color: null
-        },
-        // mix of valid and invalid
-        style2: {
-          opacity: 0,
-          color: null
-        }
-      }
-    }, result => {
-      expect(result).toContain(
-        '<div data-server-rendered="true"><p style="opacity:0;"></p></div>'
-      )
-      done()
-    })
-  })
-
-  it('numeric style value', done => {
-    renderVmWithOptions({
-      template: '<div :style="style"></div>',
-      data: {
-        style: {
-          opacity: 0, // valid, opacity is unit-less
-          top: 0, // valid, top requires unit but 0 is allowed
-          left: 10, // invalid, left requires a unit
-          marginTop: '10px' // valid
-        }
-      }
-    }, result => {
-      expect(result).toContain(
-        '<div data-server-rendered="true" style="opacity:0;top:0;margin-top:10px;"></div>'
-      )
-      done()
-    })
-  })
-
-  it('handling max stack size limit', done => {
-    const vueInstance = new Vue({
-      template: `<div class="root">
-        <child v-for="(x, i) in items" :key="i"></child>
-      </div>`,
-      components: {
-        child: {
-          template: '<div class="child"><span class="child">hi</span></div>'
-        }
-      },
-      data: {
-        items: Array(1000).fill(0)
-      }
-    })
-
-    renderToString(vueInstance, err => done(err))
-  })
-})
-
-function renderVmWithOptions (options, cb) {
-  renderToString(new Vue(options), (err, res) => {
-    expect(err).toBeNull()
-    cb(res)
-  })
-}
diff --git a/1.Vue/test/ssr/ssr-template.spec.js b/1.Vue/test/ssr/ssr-template.spec.js
deleted file mode 100644
index d30f096..0000000
--- a/1.Vue/test/ssr/ssr-template.spec.js
+++ /dev/null
@@ -1,577 +0,0 @@
-import Vue from '../../dist/vue.runtime.common.js'
-import { compileWithWebpack } from './compile-with-webpack'
-import { createRenderer } from '../../packages/vue-server-renderer'
-import VueSSRClientPlugin from '../../packages/vue-server-renderer/client-plugin'
-import { createRenderer as createBundleRenderer } from './ssr-bundle-render.spec.js'
-
-const defaultTemplate = `<html><head></head><body><!--vue-ssr-outlet--></body></html>`
-const interpolateTemplate = `<html><head><title>{{ title }}</title></head><body><!--vue-ssr-outlet-->{{{ snippet }}}</body></html>`
-
-function generateClientManifest (file, cb) {
-  compileWithWebpack(file, {
-    output: {
-      path: '/',
-      publicPath: '/',
-      filename: '[name].js'
-    },
-    optimization: {
-      runtimeChunk: {
-        name: 'manifest'
-      }
-    },
-    plugins: [
-      new VueSSRClientPlugin()
-    ]
-  }, fs => {
-    cb(JSON.parse(fs.readFileSync('/vue-ssr-client-manifest.json', 'utf-8')))
-  })
-}
-
-function createRendererWithManifest (file, options, cb) {
-  if (typeof options === 'function') {
-    cb = options
-    options = null
-  }
-  generateClientManifest(file, clientManifest => {
-    createBundleRenderer(file, Object.assign({
-      asBundle: true,
-      template: defaultTemplate,
-      clientManifest
-    }, options), cb)
-  })
-}
-
-describe('SSR: template option', () => {
-  it('renderToString', done => {
-    const renderer = createRenderer({
-      template: defaultTemplate
-    })
-
-    const context = {
-      head: '<meta name="viewport" content="width=device-width">',
-      styles: '<style>h1 { color: red }</style>',
-      state: { a: 1 }
-    }
-
-    renderer.renderToString(new Vue({
-      template: '<div>hi</div>'
-    }), context, (err, res) => {
-      expect(err).toBeNull()
-      expect(res).toContain(
-        `<html><head>${context.head}${context.styles}</head><body>` +
-        `<div data-server-rendered="true">hi</div>` +
-        `<script>window.__INITIAL_STATE__={"a":1}</script>` +
-        `</body></html>`
-      )
-      done()
-    })
-  })
-
-  it('renderToString with interpolation', done => {
-    const renderer = createRenderer({
-      template: interpolateTemplate
-    })
-
-    const context = {
-      title: '<script>hacks</script>',
-      snippet: '<div>foo</div>',
-      head: '<meta name="viewport" content="width=device-width">',
-      styles: '<style>h1 { color: red }</style>',
-      state: { a: 1 }
-    }
-
-    renderer.renderToString(new Vue({
-      template: '<div>hi</div>'
-    }), context, (err, res) => {
-      expect(err).toBeNull()
-      expect(res).toContain(
-        `<html><head>` +
-        // double mustache should be escaped
-        `<title>&lt;script&gt;hacks&lt;/script&gt;</title>` +
-        `${context.head}${context.styles}</head><body>` +
-        `<div data-server-rendered="true">hi</div>` +
-        `<script>window.__INITIAL_STATE__={"a":1}</script>` +
-        // triple should be raw
-        `<div>foo</div>` +
-        `</body></html>`
-      )
-      done()
-    })
-  })
-
-  it('renderToString with interpolation and context.rendered', done => {
-    const renderer = createRenderer({
-      template: interpolateTemplate
-    })
-
-    const context = {
-      title: '<script>hacks</script>',
-      snippet: '<div>foo</div>',
-      head: '<meta name="viewport" content="width=device-width">',
-      styles: '<style>h1 { color: red }</style>',
-      state: { a: 0 },
-      rendered: context => {
-        context.state.a = 1
-      }
-    }
-
-    renderer.renderToString(new Vue({
-      template: '<div>hi</div>'
-    }), context, (err, res) => {
-      expect(err).toBeNull()
-      expect(res).toContain(
-        `<html><head>` +
-        // double mustache should be escaped
-        `<title>&lt;script&gt;hacks&lt;/script&gt;</title>` +
-        `${context.head}${context.styles}</head><body>` +
-        `<div data-server-rendered="true">hi</div>` +
-        `<script>window.__INITIAL_STATE__={"a":1}</script>` +
-        // triple should be raw
-        `<div>foo</div>` +
-        `</body></html>`
-      )
-      done()
-    })
-  })
-
-  it('renderToString w/ template function', done => {
-    const renderer = createRenderer({
-      template: (content, context) => `<html><head>${context.head}</head>${content}</html>`
-    })
-
-    const context = {
-      head: '<meta name="viewport" content="width=device-width">'
-    }
-
-    renderer.renderToString(new Vue({
-      template: '<div>hi</div>'
-    }), context, (err, res) => {
-      expect(err).toBeNull()
-      expect(res).toContain(`<html><head>${context.head}</head><div data-server-rendered="true">hi</div></html>`)
-      done()
-    })
-  })
-
-  it('renderToString w/ template function returning Promise', done => {
-    const renderer = createRenderer({
-      template: (content, context) => new Promise((resolve) => {
-        setTimeout(() => {
-          resolve(`<html><head>${context.head}</head>${content}</html>`)
-        }, 0)
-      })
-    })
-
-    const context = {
-      head: '<meta name="viewport" content="width=device-width">'
-    }
-
-    renderer.renderToString(new Vue({
-      template: '<div>hi</div>'
-    }), context, (err, res) => {
-      expect(err).toBeNull()
-      expect(res).toContain(`<html><head>${context.head}</head><div data-server-rendered="true">hi</div></html>`)
-      done()
-    })
-  })
-
-  it('renderToString w/ template function returning Promise w/ rejection', done => {
-    const renderer = createRenderer({
-      template: () => new Promise((resolve, reject) => {
-        setTimeout(() => {
-          reject(new Error(`foo`))
-        }, 0)
-      })
-    })
-
-    const context = {
-      head: '<meta name="viewport" content="width=device-width">'
-    }
-
-    renderer.renderToString(new Vue({
-      template: '<div>hi</div>'
-    }), context, (err, res) => {
-      expect(err.message).toBe(`foo`)
-      expect(res).toBeUndefined()
-      done()
-    })
-  })
-
-  it('renderToStream', done => {
-    const renderer = createRenderer({
-      template: defaultTemplate
-    })
-
-    const context = {
-      head: '<meta name="viewport" content="width=device-width">',
-      styles: '<style>h1 { color: red }</style>',
-      state: { a: 1 }
-    }
-
-    const stream = renderer.renderToStream(new Vue({
-      template: '<div>hi</div>'
-    }), context)
-
-    let res = ''
-    stream.on('data', chunk => {
-      res += chunk
-    })
-    stream.on('end', () => {
-      expect(res).toContain(
-        `<html><head>${context.head}${context.styles}</head><body>` +
-        `<div data-server-rendered="true">hi</div>` +
-        `<script>window.__INITIAL_STATE__={"a":1}</script>` +
-        `</body></html>`
-      )
-      done()
-    })
-  })
-
-  it('renderToStream with interpolation', done => {
-    const renderer = createRenderer({
-      template: interpolateTemplate
-    })
-
-    const context = {
-      title: '<script>hacks</script>',
-      snippet: '<div>foo</div>',
-      head: '<meta name="viewport" content="width=device-width">',
-      styles: '<style>h1 { color: red }</style>',
-      state: { a: 1 }
-    }
-
-    const stream = renderer.renderToStream(new Vue({
-      template: '<div>hi</div>'
-    }), context)
-
-    let res = ''
-    stream.on('data', chunk => {
-      res += chunk
-    })
-    stream.on('end', () => {
-      expect(res).toContain(
-        `<html><head>` +
-        // double mustache should be escaped
-        `<title>&lt;script&gt;hacks&lt;/script&gt;</title>` +
-        `${context.head}${context.styles}</head><body>` +
-        `<div data-server-rendered="true">hi</div>` +
-        `<script>window.__INITIAL_STATE__={"a":1}</script>` +
-        // triple should be raw
-        `<div>foo</div>` +
-        `</body></html>`
-      )
-      done()
-    })
-  })
-
-  it('renderToStream with interpolation and context.rendered', done => {
-    const renderer = createRenderer({
-      template: interpolateTemplate
-    })
-
-    const context = {
-      title: '<script>hacks</script>',
-      snippet: '<div>foo</div>',
-      head: '<meta name="viewport" content="width=device-width">',
-      styles: '<style>h1 { color: red }</style>',
-      state: { a: 0 },
-      rendered: context => {
-        context.state.a = 1
-      }
-    }
-
-    const stream = renderer.renderToStream(new Vue({
-      template: '<div>hi</div>'
-    }), context)
-
-    let res = ''
-    stream.on('data', chunk => {
-      res += chunk
-    })
-    stream.on('end', () => {
-      expect(res).toContain(
-        `<html><head>` +
-        // double mustache should be escaped
-        `<title>&lt;script&gt;hacks&lt;/script&gt;</title>` +
-        `${context.head}${context.styles}</head><body>` +
-        `<div data-server-rendered="true">hi</div>` +
-        `<script>window.__INITIAL_STATE__={"a":1}</script>` +
-        // triple should be raw
-        `<div>foo</div>` +
-        `</body></html>`
-      )
-      done()
-    })
-  })
-
-  it('bundleRenderer + renderToString', done => {
-    createBundleRenderer('app.js', {
-      asBundle: true,
-      template: defaultTemplate
-    }, renderer => {
-      const context = {
-        head: '<meta name="viewport" content="width=device-width">',
-        styles: '<style>h1 { color: red }</style>',
-        state: { a: 1 },
-        url: '/test'
-      }
-      renderer.renderToString(context, (err, res) => {
-        expect(err).toBeNull()
-        expect(res).toContain(
-          `<html><head>${context.head}${context.styles}</head><body>` +
-          `<div data-server-rendered="true">/test</div>` +
-          `<script>window.__INITIAL_STATE__={"a":1}</script>` +
-          `</body></html>`
-        )
-        expect(context.msg).toBe('hello')
-        done()
-      })
-    })
-  })
-
-  it('bundleRenderer + renderToStream', done => {
-    createBundleRenderer('app.js', {
-      asBundle: true,
-      template: defaultTemplate
-    }, renderer => {
-      const context = {
-        head: '<meta name="viewport" content="width=device-width">',
-        styles: '<style>h1 { color: red }</style>',
-        state: { a: 1 },
-        url: '/test'
-      }
-      const stream = renderer.renderToStream(context)
-      let res = ''
-      stream.on('data', chunk => {
-        res += chunk.toString()
-      })
-      stream.on('end', () => {
-        expect(res).toContain(
-          `<html><head>${context.head}${context.styles}</head><body>` +
-          `<div data-server-rendered="true">/test</div>` +
-          `<script>window.__INITIAL_STATE__={"a":1}</script>` +
-          `</body></html>`
-        )
-        expect(context.msg).toBe('hello')
-        done()
-      })
-    })
-  })
-
-  const expectedHTMLWithManifest = (options = {}) =>
-    `<html><head>` +
-      // used chunks should have preload
-      `<link rel="preload" href="/manifest.js" as="script">` +
-      `<link rel="preload" href="/main.js" as="script">` +
-      `<link rel="preload" href="/0.js" as="script">` +
-      `<link rel="preload" href="/test.css" as="style">` +
-      // images and fonts are only preloaded when explicitly asked for
-      (options.preloadOtherAssets ? `<link rel="preload" href="/test.png" as="image">` : ``) +
-      (options.preloadOtherAssets ? `<link rel="preload" href="/test.woff2" as="font" type="font/woff2" crossorigin>` : ``) +
-      // unused chunks should have prefetch
-      (options.noPrefetch ? `` : `<link rel="prefetch" href="/1.js">`) +
-      // css assets should be loaded
-      `<link rel="stylesheet" href="/test.css">` +
-    `</head><body>` +
-      `<div data-server-rendered="true"><div>async test.woff2 test.png</div></div>` +
-      // state should be inlined before scripts
-      `<script>window.${options.stateKey || '__INITIAL_STATE__'}={"a":1}</script>` +
-      // manifest chunk should be first
-      `<script src="/manifest.js" defer></script>` +
-      // async chunks should be before main chunk
-      `<script src="/0.js" defer></script>` +
-      `<script src="/main.js" defer></script>` +
-    `</body></html>`
-
-  createClientManifestAssertions(true)
-  createClientManifestAssertions(false)
-
-  function createClientManifestAssertions (runInNewContext) {
-    it('bundleRenderer + renderToString + clientManifest ()', done => {
-      createRendererWithManifest('split.js', { runInNewContext }, renderer => {
-        renderer.renderToString({ state: { a: 1 }}, (err, res) => {
-          expect(err).toBeNull()
-          expect(res).toContain(expectedHTMLWithManifest())
-          done()
-        })
-      })
-    })
-
-    it('bundleRenderer + renderToStream + clientManifest + shouldPreload', done => {
-      createRendererWithManifest('split.js', {
-        runInNewContext,
-        shouldPreload: (file, type) => {
-          if (type === 'image' || type === 'script' || type === 'font' || type === 'style') {
-            return true
-          }
-        }
-      }, renderer => {
-        const stream = renderer.renderToStream({ state: { a: 1 }})
-        let res = ''
-        stream.on('data', chunk => {
-          res += chunk.toString()
-        })
-        stream.on('end', () => {
-          expect(res).toContain(expectedHTMLWithManifest({
-            preloadOtherAssets: true
-          }))
-          done()
-        })
-      })
-    })
-
-    it('bundleRenderer + renderToStream + clientManifest + shouldPrefetch', done => {
-      createRendererWithManifest('split.js', {
-        runInNewContext,
-        shouldPrefetch: (file, type) => {
-          if (type === 'script') {
-            return false
-          }
-        }
-      }, renderer => {
-        const stream = renderer.renderToStream({ state: { a: 1 }})
-        let res = ''
-        stream.on('data', chunk => {
-          res += chunk.toString()
-        })
-        stream.on('end', () => {
-          expect(res).toContain(expectedHTMLWithManifest({
-            noPrefetch: true
-          }))
-          done()
-        })
-      })
-    })
-
-    it('bundleRenderer + renderToString + clientManifest + inject: false', done => {
-      createRendererWithManifest('split.js', {
-        runInNewContext,
-        template: `<html>` +
-          `<head>{{{ renderResourceHints() }}}{{{ renderStyles() }}}</head>` +
-          `<body><!--vue-ssr-outlet-->{{{ renderState({ windowKey: '__FOO__', contextKey: 'foo' }) }}}{{{ renderScripts() }}}</body>` +
-        `</html>`,
-        inject: false
-      }, renderer => {
-        const context = { foo: { a: 1 }}
-        renderer.renderToString(context, (err, res) => {
-          expect(err).toBeNull()
-          expect(res).toContain(expectedHTMLWithManifest({
-            stateKey: '__FOO__'
-          }))
-          done()
-        })
-      })
-    })
-
-    it('bundleRenderer + renderToString + clientManifest + no template', done => {
-      createRendererWithManifest('split.js', {
-        runInNewContext,
-        template: null
-      }, renderer => {
-        const context = { foo: { a: 1 }}
-        renderer.renderToString(context, (err, res) => {
-          expect(err).toBeNull()
-
-          const customOutput =
-            `<html><head>${
-              context.renderResourceHints() +
-              context.renderStyles()
-            }</head><body>${
-              res +
-              context.renderState({
-                windowKey: '__FOO__',
-                contextKey: 'foo'
-              }) +
-              context.renderScripts()
-            }</body></html>`
-
-          expect(customOutput).toContain(expectedHTMLWithManifest({
-            stateKey: '__FOO__'
-          }))
-          done()
-        })
-      })
-    })
-
-    it('whitespace insensitive interpolation', done => {
-      const interpolateTemplate = `<html><head><title>{{title}}</title></head><body><!--vue-ssr-outlet-->{{{snippet}}}</body></html>`
-      const renderer = createRenderer({
-        template: interpolateTemplate
-      })
-
-      const context = {
-        title: '<script>hacks</script>',
-        snippet: '<div>foo</div>',
-        head: '<meta name="viewport" content="width=device-width">',
-        styles: '<style>h1 { color: red }</style>',
-        state: { a: 1 }
-      }
-
-      renderer.renderToString(new Vue({
-        template: '<div>hi</div>'
-      }), context, (err, res) => {
-        expect(err).toBeNull()
-        expect(res).toContain(
-          `<html><head>` +
-          // double mustache should be escaped
-          `<title>&lt;script&gt;hacks&lt;/script&gt;</title>` +
-          `${context.head}${context.styles}</head><body>` +
-          `<div data-server-rendered="true">hi</div>` +
-          `<script>window.__INITIAL_STATE__={"a":1}</script>` +
-          // triple should be raw
-          `<div>foo</div>` +
-          `</body></html>`
-        )
-        done()
-      })
-    })
-
-    it('renderToString + nonce', done => {
-      const interpolateTemplate = `<html><head><title>hello</title></head><body><!--vue-ssr-outlet--></body></html>`
-      const renderer = createRenderer({
-        template: interpolateTemplate
-      })
-
-      const context = {
-        state: { a: 1 },
-        nonce: '4AEemGb0xJptoIGFP3Nd'
-      }
-
-      renderer.renderToString(new Vue({
-        template: '<div>hi</div>'
-      }), context, (err, res) => {
-        expect(err).toBeNull()
-        expect(res).toContain(
-          `<html><head>` +
-          `<title>hello</title>` +
-          `</head><body>` +
-          `<div data-server-rendered="true">hi</div>` +
-          `<script nonce="4AEemGb0xJptoIGFP3Nd">window.__INITIAL_STATE__={"a":1}</script>` +
-          `</body></html>`
-        )
-        done()
-      })
-    })
-
-    it('renderToString + custom serializer', done => {
-      const expected = `{"foo":123}`
-      const renderer = createRenderer({
-        template: defaultTemplate,
-        serializer: () => expected
-      })
-
-      const context = {
-        state: { a: 1 }
-      }
-
-      renderer.renderToString(new Vue({
-        template: '<div>hi</div>'
-      }), context, (err, res) => {
-        expect(err).toBeNull()
-        expect(res).toContain(
-          `<script>window.__INITIAL_STATE__=${expected}</script>`
-        )
-        done()
-      })
-    })
-  }
-})
diff --git a/1.Vue/test/unit/.eslintrc.json b/1.Vue/test/unit/.eslintrc.json
deleted file mode 100644
index d1ccc04..0000000
--- a/1.Vue/test/unit/.eslintrc.json
+++ /dev/null
@@ -1,15 +0,0 @@
-{
-  "env": {
-    "jasmine": true
-  },
-  "globals": {
-    "waitForUpdate": true,
-    "triggerEvent": true,
-    "createTextVNode": true
-  },
-  "plugins": ["jasmine"],
-  "rules": {
-    "jasmine/no-focused-tests": 2,
-    "no-unused-vars": 0
-  }
-}
diff --git a/1.Vue/test/unit/features/component/component-async.spec.js b/1.Vue/test/unit/features/component/component-async.spec.js
deleted file mode 100644
index 1e492f7..0000000
--- a/1.Vue/test/unit/features/component/component-async.spec.js
+++ /dev/null
@@ -1,439 +0,0 @@
-import Vue from 'vue'
-import { Promise } from 'es6-promise'
-
-describe('Component async', () => {
-
-  const oldSetTimeout = window.setTimeout;
-  const oldClearTimeout = window.clearTimeout;
-
-  // will contain pending timeouts set during the test iteration
-  // will contain the id of the timeout as the key, and the the millisecond timeout as the value
-  // this helps to identify the timeout that is still pending
-  let timeoutsPending = {};
-
-  beforeEach(function () {
-    // reset the timeouts for this iteration
-    timeoutsPending = {};
-
-    window.setTimeout = function(func, delay) {
-      let id = oldSetTimeout(function() {
-        delete timeoutsPending[id];
-        func();
-      }, delay);
-      timeoutsPending[id] = delay;
-      return id
-    };
-
-    window.clearTimeout = function(id) {
-      oldClearTimeout(id);
-      delete timeoutsPending[id];
-    };
-  })
-
-  afterEach(function () {
-    window.setTimeout = oldSetTimeout;
-    window.clearTimeout = oldClearTimeout;
-    // after the test is complete no timeouts that have been set up during the test should still be active
-    // compare stringified JSON for better error message containing ID and millisecond timeout
-    expect(JSON.stringify(timeoutsPending)).toEqual(JSON.stringify({}))
-  })
-
-  it('normal', done => {
-    const vm = new Vue({
-      template: '<div><test></test></div>',
-      components: {
-        test: (resolve) => {
-          setTimeout(() => {
-            resolve({
-              template: '<div>hi</div>'
-            })
-            // wait for parent update
-            Vue.nextTick(next)
-          }, 0)
-        }
-      }
-    }).$mount()
-    expect(vm.$el.innerHTML).toBe('<!---->')
-    expect(vm.$children.length).toBe(0)
-    function next () {
-      expect(vm.$el.innerHTML).toBe('<div>hi</div>')
-      expect(vm.$children.length).toBe(1)
-      done()
-    }
-  })
-
-  it('resolve ES module default', done => {
-    const vm = new Vue({
-      template: '<div><test></test></div>',
-      components: {
-        test: (resolve) => {
-          setTimeout(() => {
-            resolve({
-              __esModule: true,
-              default: {
-                template: '<div>hi</div>'
-              }
-            })
-            // wait for parent update
-            Vue.nextTick(next)
-          }, 0)
-        }
-      }
-    }).$mount()
-    expect(vm.$el.innerHTML).toBe('<!---->')
-    expect(vm.$children.length).toBe(0)
-    function next () {
-      expect(vm.$el.innerHTML).toBe('<div>hi</div>')
-      expect(vm.$children.length).toBe(1)
-      done()
-    }
-  })
-
-  it('as root', done => {
-    const vm = new Vue({
-      template: '<test></test>',
-      components: {
-        test: resolve => {
-          setTimeout(() => {
-            resolve({
-              template: '<div>hi</div>'
-            })
-            // wait for parent update
-            Vue.nextTick(next)
-          }, 0)
-        }
-      }
-    }).$mount()
-    expect(vm.$el.nodeType).toBe(8)
-    expect(vm.$children.length).toBe(0)
-    function next () {
-      expect(vm.$el.nodeType).toBe(1)
-      expect(vm.$el.outerHTML).toBe('<div>hi</div>')
-      expect(vm.$children.length).toBe(1)
-      done()
-    }
-  })
-
-  it('dynamic', done => {
-    const vm = new Vue({
-      template: '<component :is="view"></component>',
-      data: {
-        view: 'view-a'
-      },
-      components: {
-        'view-a': resolve => {
-          setTimeout(() => {
-            resolve({
-              template: '<div>A</div>'
-            })
-            Vue.nextTick(step1)
-          }, 0)
-        },
-        'view-b': resolve => {
-          setTimeout(() => {
-            resolve({
-              template: '<p>B</p>'
-            })
-            Vue.nextTick(step2)
-          }, 0)
-        }
-      }
-    }).$mount()
-    let aCalled = false
-    function step1 () {
-      // ensure A is resolved only once
-      expect(aCalled).toBe(false)
-      aCalled = true
-      expect(vm.$el.tagName).toBe('DIV')
-      expect(vm.$el.textContent).toBe('A')
-      vm.view = 'view-b'
-    }
-    function step2 () {
-      expect(vm.$el.tagName).toBe('P')
-      expect(vm.$el.textContent).toBe('B')
-      vm.view = 'view-a'
-      waitForUpdate(function () {
-        expect(vm.$el.tagName).toBe('DIV')
-        expect(vm.$el.textContent).toBe('A')
-      }).then(done)
-    }
-  })
-
-  it('warn reject', () => {
-    new Vue({
-      template: '<test></test>',
-      components: {
-        test: (resolve, reject) => {
-          reject('nooooo')
-        }
-      }
-    }).$mount()
-    expect('Reason: nooooo').toHaveBeenWarned()
-  })
-
-  it('with v-for', done => {
-    const vm = new Vue({
-      template: '<div><test v-for="n in list" :key="n" :n="n"></test></div>',
-      data: {
-        list: [1, 2, 3]
-      },
-      components: {
-        test: resolve => {
-          setTimeout(() => {
-            resolve({
-              props: ['n'],
-              template: '<div>{{n}}</div>'
-            })
-            Vue.nextTick(next)
-          }, 0)
-        }
-      }
-    }).$mount()
-    function next () {
-      expect(vm.$el.innerHTML).toBe('<div>1</div><div>2</div><div>3</div>')
-      done()
-    }
-  })
-
-  it('returning Promise', done => {
-    const vm = new Vue({
-      template: '<div><test></test></div>',
-      components: {
-        test: () => {
-          return new Promise(resolve => {
-            setTimeout(() => {
-              resolve({
-                template: '<div>hi</div>'
-              })
-              // wait for promise resolve and then parent update
-              Promise.resolve().then(() => {
-                Vue.nextTick(next)
-              })
-            }, 0)
-          })
-        }
-      }
-    }).$mount()
-    expect(vm.$el.innerHTML).toBe('<!---->')
-    expect(vm.$children.length).toBe(0)
-    function next () {
-      expect(vm.$el.innerHTML).toBe('<div>hi</div>')
-      expect(vm.$children.length).toBe(1)
-      done()
-    }
-  })
-
-  describe('loading/error/timeout', () => {
-    it('with loading component', done => {
-      const vm = new Vue({
-        template: `<div><test/></div>`,
-        components: {
-          test: () => ({
-            component: new Promise(resolve => {
-              setTimeout(() => {
-                resolve({ template: '<div>hi</div>' })
-                // wait for promise resolve and then parent update
-                Promise.resolve().then(() => {
-                  Vue.nextTick(next)
-                })
-              }, 50)
-            }),
-            loading: { template: `<div>loading</div>` },
-            delay: 1
-          })
-        }
-      }).$mount()
-
-      expect(vm.$el.innerHTML).toBe('<!---->')
-
-      let loadingAsserted = false
-      setTimeout(() => {
-        Vue.nextTick(() => {
-          loadingAsserted = true
-          expect(vm.$el.textContent).toBe('loading')
-        })
-      }, 1)
-
-      function next () {
-        expect(loadingAsserted).toBe(true)
-        expect(vm.$el.textContent).toBe('hi')
-        done()
-      }
-    })
-
-    it('with loading component (0 delay)', done => {
-      const vm = new Vue({
-        template: `<div><test/></div>`,
-        components: {
-          test: () => ({
-            component: new Promise(resolve => {
-              setTimeout(() => {
-                resolve({ template: '<div>hi</div>' })
-                // wait for promise resolve and then parent update
-                Promise.resolve().then(() => {
-                  Vue.nextTick(next)
-                })
-              }, 50)
-            }),
-            loading: { template: `<div>loading</div>` },
-            delay: 0
-          })
-        }
-      }).$mount()
-
-      expect(vm.$el.textContent).toBe('loading')
-
-      function next () {
-        expect(vm.$el.textContent).toBe('hi')
-        done()
-      }
-    })
-
-    it('with error component', done => {
-      const vm = new Vue({
-        template: `<div><test/></div>`,
-        components: {
-          test: () => ({
-            component: new Promise((resolve, reject) => {
-              setTimeout(() => {
-                reject()
-                // wait for promise resolve and then parent update
-                Promise.resolve().then(() => {
-                  Vue.nextTick(next)
-                })
-              }, 50)
-            }),
-            loading: { template: `<div>loading</div>` },
-            error: { template: `<div>error</div>` },
-            delay: 0
-          })
-        }
-      }).$mount()
-
-      expect(vm.$el.textContent).toBe('loading')
-
-      function next () {
-        expect(`Failed to resolve async component`).toHaveBeenWarned()
-        expect(vm.$el.textContent).toBe('error')
-        done()
-      }
-    })
-
-    it('with error component + timeout', done => {
-      const vm = new Vue({
-        template: `<div><test/></div>`,
-        components: {
-          test: () => ({
-            component: new Promise((resolve, reject) => {
-              setTimeout(() => {
-                resolve({ template: '<div>hi</div>' })
-                // wait for promise resolve and then parent update
-                Promise.resolve().then(() => {
-                  Vue.nextTick(next)
-                })
-              }, 50)
-            }),
-            loading: { template: `<div>loading</div>` },
-            error: { template: `<div>error</div>` },
-            delay: 0,
-            timeout: 1
-          })
-        }
-      }).$mount()
-
-      expect(vm.$el.textContent).toBe('loading')
-
-      setTimeout(() => {
-        Vue.nextTick(() => {
-          expect(`Failed to resolve async component`).toHaveBeenWarned()
-          expect(vm.$el.textContent).toBe('error')
-        })
-      }, 1)
-
-      function next () {
-        expect(vm.$el.textContent).toBe('error') // late resolve ignored
-        done()
-      }
-    })
-
-    it('should not trigger timeout if resolved', done => {
-      const vm = new Vue({
-        template: `<div><test/></div>`,
-        components: {
-          test: () => ({
-            component: new Promise((resolve, reject) => {
-              setTimeout(() => {
-                resolve({ template: '<div>hi</div>' })
-              }, 10)
-            }),
-            error: { template: `<div>error</div>` },
-            timeout: 20
-          })
-        }
-      }).$mount()
-
-      setTimeout(() => {
-        expect(vm.$el.textContent).toBe('hi')
-        expect(`Failed to resolve async component`).not.toHaveBeenWarned()
-        done()
-      }, 50)
-    })
-
-    it('should not have running timeout/loading if resolved', done => {
-      const vm = new Vue({
-        template: `<div><test/></div>`,
-        components: {
-          test: () => ({
-            component: new Promise((resolve, reject) => {
-              setTimeout(() => {
-                resolve({ template: '<div>hi</div>' })
-                Promise.resolve().then(() => {
-                  Vue.nextTick(next)
-                })
-              }, 10)
-            }),
-            loading: { template: `<div>loading</div>` },
-            delay: 30,
-            error: { template: `<div>error</div>` },
-            timeout: 40
-          })
-        }
-      }).$mount()
-
-      function next () {
-        expect(vm.$el.textContent).toBe('hi')
-        // the afterEach() will ensure that the timeouts for delay and timeout have been cleared
-        done()
-      }
-    })
-
-    // #7107
-    it(`should work when resolving sync in sibling component's mounted hook`, done => {
-      let resolveTwo
-
-      const vm = new Vue({
-        template: `<div><one/> <two/></div>`,
-        components: {
-          one: {
-            template: `<div>one</div>`,
-            mounted () {
-              resolveTwo()
-            }
-          },
-          two: resolve => {
-            resolveTwo = () => {
-              resolve({
-                template: `<div>two</div>`
-              })
-            }
-          }
-        }
-      }).$mount()
-
-      expect(vm.$el.textContent).toBe('one ')
-      waitForUpdate(() => {
-        expect(vm.$el.textContent).toBe('one two')
-      }).then(done)
-    })
-  })
-})
diff --git a/1.Vue/test/unit/features/component/component-keep-alive.spec.js b/1.Vue/test/unit/features/component/component-keep-alive.spec.js
deleted file mode 100644
index a2cdf6a..0000000
--- a/1.Vue/test/unit/features/component/component-keep-alive.spec.js
+++ /dev/null
@@ -1,1186 +0,0 @@
-import Vue from 'vue'
-import injectStyles from '../transition/inject-styles'
-import { isIE9 } from 'core/util/env'
-import { nextFrame } from 'web/runtime/transition-util'
-
-describe('Component keep-alive', () => {
-  const { duration, buffer } = injectStyles()
-  let components, one, two, el
-  beforeEach(() => {
-    one = {
-      template: '<div>one</div>',
-      created: jasmine.createSpy('one created'),
-      mounted: jasmine.createSpy('one mounted'),
-      activated: jasmine.createSpy('one activated'),
-      deactivated: jasmine.createSpy('one deactivated'),
-      destroyed: jasmine.createSpy('one destroyed')
-    }
-    two = {
-      template: '<div>two</div>',
-      created: jasmine.createSpy('two created'),
-      mounted: jasmine.createSpy('two mounted'),
-      activated: jasmine.createSpy('two activated'),
-      deactivated: jasmine.createSpy('two deactivated'),
-      destroyed: jasmine.createSpy('two destroyed')
-    }
-    components = {
-      one,
-      two
-    }
-    el = document.createElement('div')
-    document.body.appendChild(el)
-  })
-
-  function assertHookCalls (component, callCounts) {
-    expect([
-      component.created.calls.count(),
-      component.mounted.calls.count(),
-      component.activated.calls.count(),
-      component.deactivated.calls.count(),
-      component.destroyed.calls.count()
-    ]).toEqual(callCounts)
-  }
-
-  it('should work', done => {
-    const vm = new Vue({
-      template: `
-        <div v-if="ok">
-          <keep-alive>
-            <component :is="view"></component>
-          </keep-alive>
-        </div>
-      `,
-      data: {
-        view: 'one',
-        ok: true
-      },
-      components
-    }).$mount()
-    expect(vm.$el.textContent).toBe('one')
-    assertHookCalls(one, [1, 1, 1, 0, 0])
-    assertHookCalls(two, [0, 0, 0, 0, 0])
-    vm.view = 'two'
-    waitForUpdate(() => {
-      expect(vm.$el.textContent).toBe('two')
-      assertHookCalls(one, [1, 1, 1, 1, 0])
-      assertHookCalls(two, [1, 1, 1, 0, 0])
-      vm.view = 'one'
-    }).then(() => {
-      expect(vm.$el.textContent).toBe('one')
-      assertHookCalls(one, [1, 1, 2, 1, 0])
-      assertHookCalls(two, [1, 1, 1, 1, 0])
-      vm.view = 'two'
-    }).then(() => {
-      expect(vm.$el.textContent).toBe('two')
-      assertHookCalls(one, [1, 1, 2, 2, 0])
-      assertHookCalls(two, [1, 1, 2, 1, 0])
-      vm.ok = false // teardown
-    }).then(() => {
-      expect(vm.$el.textContent).toBe('')
-      assertHookCalls(one, [1, 1, 2, 2, 1])
-      assertHookCalls(two, [1, 1, 2, 2, 1])
-    }).then(done)
-  })
-
-  it('should invoke hooks on the entire sub tree', done => {
-    one.template = '<two/>'
-    one.components = { two }
-
-    const vm = new Vue({
-      template: `
-        <div>
-          <keep-alive>
-            <one v-if="ok"/>
-          </keep-alive>
-        </div>
-      `,
-      data: {
-        ok: true
-      },
-      components
-    }).$mount()
-
-    expect(vm.$el.textContent).toBe('two')
-    assertHookCalls(one, [1, 1, 1, 0, 0])
-    assertHookCalls(two, [1, 1, 1, 0, 0])
-    vm.ok = false
-    waitForUpdate(() => {
-      expect(vm.$el.textContent).toBe('')
-      assertHookCalls(one, [1, 1, 1, 1, 0])
-      assertHookCalls(two, [1, 1, 1, 1, 0])
-      vm.ok = true
-    }).then(() => {
-      expect(vm.$el.textContent).toBe('two')
-      assertHookCalls(one, [1, 1, 2, 1, 0])
-      assertHookCalls(two, [1, 1, 2, 1, 0])
-      vm.ok = false
-    }).then(() => {
-      expect(vm.$el.textContent).toBe('')
-      assertHookCalls(one, [1, 1, 2, 2, 0])
-      assertHookCalls(two, [1, 1, 2, 2, 0])
-    }).then(done)
-  })
-
-  it('should handle nested keep-alive hooks properly', done => {
-    one.template = '<keep-alive><two v-if="ok" /></keep-alive>'
-    one.data = () => ({ ok: true })
-    one.components = { two }
-
-    const vm = new Vue({
-      template: `
-        <div>
-          <keep-alive>
-            <one v-if="ok" ref="one" />
-          </keep-alive>
-        </div>
-      `,
-      data: {
-        ok: true
-      },
-      components
-    }).$mount()
-
-    const oneInstance = vm.$refs.one
-    expect(vm.$el.textContent).toBe('two')
-    assertHookCalls(one, [1, 1, 1, 0, 0])
-    assertHookCalls(two, [1, 1, 1, 0, 0])
-    vm.ok = false
-    waitForUpdate(() => {
-      expect(vm.$el.textContent).toBe('')
-      assertHookCalls(one, [1, 1, 1, 1, 0])
-      assertHookCalls(two, [1, 1, 1, 1, 0])
-    }).then(() => {
-      vm.ok = true
-    }).then(() => {
-      expect(vm.$el.textContent).toBe('two')
-      assertHookCalls(one, [1, 1, 2, 1, 0])
-      assertHookCalls(two, [1, 1, 2, 1, 0])
-    }).then(() => {
-      // toggle sub component when activated
-      oneInstance.ok = false
-    }).then(() => {
-      expect(vm.$el.textContent).toBe('')
-      assertHookCalls(one, [1, 1, 2, 1, 0])
-      assertHookCalls(two, [1, 1, 2, 2, 0])
-    }).then(() => {
-      oneInstance.ok = true
-    }).then(() => {
-      expect(vm.$el.textContent).toBe('two')
-      assertHookCalls(one, [1, 1, 2, 1, 0])
-      assertHookCalls(two, [1, 1, 3, 2, 0])
-    }).then(() => {
-      vm.ok = false
-    }).then(() => {
-      expect(vm.$el.textContent).toBe('')
-      assertHookCalls(one, [1, 1, 2, 2, 0])
-      assertHookCalls(two, [1, 1, 3, 3, 0])
-    }).then(() => {
-      // toggle sub component when parent is deactivated
-      oneInstance.ok = false
-    }).then(() => {
-      expect(vm.$el.textContent).toBe('')
-      assertHookCalls(one, [1, 1, 2, 2, 0])
-      assertHookCalls(two, [1, 1, 3, 3, 0]) // should not be affected
-    }).then(() => {
-      oneInstance.ok = true
-    }).then(() => {
-      expect(vm.$el.textContent).toBe('')
-      assertHookCalls(one, [1, 1, 2, 2, 0])
-      assertHookCalls(two, [1, 1, 3, 3, 0]) // should not be affected
-    }).then(() => {
-      vm.ok = true
-    }).then(() => {
-      expect(vm.$el.textContent).toBe('two')
-      assertHookCalls(one, [1, 1, 3, 2, 0])
-      assertHookCalls(two, [1, 1, 4, 3, 0])
-    }).then(() => {
-      oneInstance.ok = false
-      vm.ok = false
-    }).then(() => {
-      expect(vm.$el.textContent).toBe('')
-      assertHookCalls(one, [1, 1, 3, 3, 0])
-      assertHookCalls(two, [1, 1, 4, 4, 0])
-    }).then(() => {
-      vm.ok = true
-    }).then(() => {
-      expect(vm.$el.textContent).toBe('')
-      assertHookCalls(one, [1, 1, 4, 3, 0])
-      assertHookCalls(two, [1, 1, 4, 4, 0]) // should remain inactive
-    }).then(done)
-  })
-
-  function sharedAssertions (vm, done) {
-    expect(vm.$el.textContent).toBe('one')
-    assertHookCalls(one, [1, 1, 1, 0, 0])
-    assertHookCalls(two, [0, 0, 0, 0, 0])
-    vm.view = 'two'
-    waitForUpdate(() => {
-      expect(vm.$el.textContent).toBe('two')
-      assertHookCalls(one, [1, 1, 1, 1, 0])
-      assertHookCalls(two, [1, 1, 0, 0, 0])
-      vm.view = 'one'
-    }).then(() => {
-      expect(vm.$el.textContent).toBe('one')
-      assertHookCalls(one, [1, 1, 2, 1, 0])
-      assertHookCalls(two, [1, 1, 0, 0, 1])
-      vm.view = 'two'
-    }).then(() => {
-      expect(vm.$el.textContent).toBe('two')
-      assertHookCalls(one, [1, 1, 2, 2, 0])
-      assertHookCalls(two, [2, 2, 0, 0, 1])
-      vm.ok = false // teardown
-    }).then(() => {
-      expect(vm.$el.textContent).toBe('')
-      assertHookCalls(one, [1, 1, 2, 2, 1])
-      assertHookCalls(two, [2, 2, 0, 0, 2])
-    }).then(done)
-  }
-
-  it('include (string)', done => {
-    const vm = new Vue({
-      template: `
-        <div v-if="ok">
-          <keep-alive include="one">
-            <component :is="view"></component>
-          </keep-alive>
-        </div>
-      `,
-      data: {
-        view: 'one',
-        ok: true
-      },
-      components
-    }).$mount()
-    sharedAssertions(vm, done)
-  })
-
-  it('include (regex)', done => {
-    const vm = new Vue({
-      template: `
-        <div v-if="ok">
-          <keep-alive :include="/^one$/">
-            <component :is="view"></component>
-          </keep-alive>
-        </div>
-      `,
-      data: {
-        view: 'one',
-        ok: true
-      },
-      components
-    }).$mount()
-    sharedAssertions(vm, done)
-  })
-
-  it('include (array)', done => {
-    const vm = new Vue({
-      template: `
-        <div v-if="ok">
-          <keep-alive :include="['one']">
-            <component :is="view"></component>
-          </keep-alive>
-        </div>
-      `,
-      data: {
-        view: 'one',
-        ok: true
-      },
-      components
-    }).$mount()
-    sharedAssertions(vm, done)
-  })
-
-  it('exclude (string)', done => {
-    const vm = new Vue({
-      template: `
-        <div v-if="ok">
-          <keep-alive exclude="two">
-            <component :is="view"></component>
-          </keep-alive>
-        </div>
-      `,
-      data: {
-        view: 'one',
-        ok: true
-      },
-      components
-    }).$mount()
-    sharedAssertions(vm, done)
-  })
-
-  it('exclude (regex)', done => {
-    const vm = new Vue({
-      template: `
-        <div v-if="ok">
-          <keep-alive :exclude="/^two$/">
-            <component :is="view"></component>
-          </keep-alive>
-        </div>
-      `,
-      data: {
-        view: 'one',
-        ok: true
-      },
-      components
-    }).$mount()
-    sharedAssertions(vm, done)
-  })
-
-  it('exclude (array)', done => {
-    const vm = new Vue({
-      template: `
-        <div v-if="ok">
-          <keep-alive :exclude="['two']">
-            <component :is="view"></component>
-          </keep-alive>
-        </div>
-      `,
-      data: {
-        view: 'one',
-        ok: true
-      },
-      components
-    }).$mount()
-    sharedAssertions(vm, done)
-  })
-
-  it('include + exclude', done => {
-    const vm = new Vue({
-      template: `
-        <div v-if="ok">
-          <keep-alive include="one,two" exclude="two">
-            <component :is="view"></component>
-          </keep-alive>
-        </div>
-      `,
-      data: {
-        view: 'one',
-        ok: true
-      },
-      components
-    }).$mount()
-    sharedAssertions(vm, done)
-  })
-
-  it('prune cache on include/exclude change', done => {
-    const vm = new Vue({
-      template: `
-        <div>
-          <keep-alive :include="include">
-            <component :is="view"></component>
-          </keep-alive>
-        </div>
-      `,
-      data: {
-        view: 'one',
-        include: 'one,two'
-      },
-      components
-    }).$mount()
-
-    vm.view = 'two'
-    waitForUpdate(() => {
-      assertHookCalls(one, [1, 1, 1, 1, 0])
-      assertHookCalls(two, [1, 1, 1, 0, 0])
-      vm.include = 'two'
-    }).then(() => {
-      assertHookCalls(one, [1, 1, 1, 1, 1])
-      assertHookCalls(two, [1, 1, 1, 0, 0])
-      vm.view = 'one'
-    }).then(() => {
-      assertHookCalls(one, [2, 2, 1, 1, 1])
-      assertHookCalls(two, [1, 1, 1, 1, 0])
-    }).then(done)
-  })
-
-  it('prune cache on include/exclude change + view switch', done => {
-    const vm = new Vue({
-      template: `
-        <div>
-          <keep-alive :include="include">
-            <component :is="view"></component>
-          </keep-alive>
-        </div>
-      `,
-      data: {
-        view: 'one',
-        include: 'one,two'
-      },
-      components
-    }).$mount()
-
-    vm.view = 'two'
-    waitForUpdate(() => {
-      assertHookCalls(one, [1, 1, 1, 1, 0])
-      assertHookCalls(two, [1, 1, 1, 0, 0])
-      vm.include = 'one'
-      vm.view = 'one'
-    }).then(() => {
-      assertHookCalls(one, [1, 1, 2, 1, 0])
-      // two should be pruned
-      assertHookCalls(two, [1, 1, 1, 1, 1])
-    }).then(done)
-  })
-
-  it('should not prune currently active instance', done => {
-    const vm = new Vue({
-      template: `
-        <div>
-          <keep-alive :include="include">
-            <component :is="view"></component>
-          </keep-alive>
-        </div>
-      `,
-      data: {
-        view: 'one',
-        include: 'one,two'
-      },
-      components
-    }).$mount()
-
-    vm.include = 'two'
-    waitForUpdate(() => {
-      assertHookCalls(one, [1, 1, 1, 0, 0])
-      assertHookCalls(two, [0, 0, 0, 0, 0])
-      vm.view = 'two'
-    }).then(() => {
-      assertHookCalls(one, [1, 1, 1, 0, 1])
-      assertHookCalls(two, [1, 1, 1, 0, 0])
-    }).then(done)
-  })
-
-  // #3882
-  it('deeply nested keep-alive should be destroyed properly', done => {
-    one.template = `<div><keep-alive><two></two></keep-alive></div>`
-    one.components = { two }
-    const vm = new Vue({
-      template: `<div><parent v-if="ok"></parent></div>`,
-      data: { ok: true },
-      components: {
-        parent: {
-          template: `<div><keep-alive><one></one></keep-alive></div>`,
-          components: { one }
-        }
-      }
-    }).$mount()
-
-    assertHookCalls(one, [1, 1, 1, 0, 0])
-    assertHookCalls(two, [1, 1, 1, 0, 0])
-
-    vm.ok = false
-    waitForUpdate(() => {
-      assertHookCalls(one, [1, 1, 1, 1, 1])
-      assertHookCalls(two, [1, 1, 1, 1, 1])
-    }).then(done)
-  })
-
-  // #4237
-  it('should update latest props/listeners for a re-activated component', done => {
-    const one = {
-      props: ['prop'],
-      template: `<div>one {{ prop }}</div>`
-    }
-    const two = {
-      props: ['prop'],
-      template: `<div>two {{ prop }}</div>`
-    }
-    const vm = new Vue({
-      data: { view: 'one', n: 1 },
-      template: `
-        <div>
-          <keep-alive>
-            <component :is="view" :prop="n"></component>
-          </keep-alive>
-        </div>
-      `,
-      components: { one, two }
-    }).$mount()
-
-    expect(vm.$el.textContent).toBe('one 1')
-    vm.n++
-    waitForUpdate(() => {
-      expect(vm.$el.textContent).toBe('one 2')
-      vm.view = 'two'
-    }).then(() => {
-      expect(vm.$el.textContent).toBe('two 2')
-    }).then(done)
-  })
-
-  it('max', done => {
-    const spyA = jasmine.createSpy()
-    const spyB = jasmine.createSpy()
-    const spyC = jasmine.createSpy()
-    const spyAD = jasmine.createSpy()
-    const spyBD = jasmine.createSpy()
-    const spyCD = jasmine.createSpy()
-
-    function assertCount (calls) {
-      expect([
-        spyA.calls.count(),
-        spyAD.calls.count(),
-        spyB.calls.count(),
-        spyBD.calls.count(),
-        spyC.calls.count(),
-        spyCD.calls.count()
-      ]).toEqual(calls)
-    }
-
-    const vm = new Vue({
-      template: `
-        <keep-alive max="2">
-          <component :is="n"></component>
-        </keep-alive>
-      `,
-      data: {
-        n: 'aa'
-      },
-      components: {
-        aa: {
-          template: '<div>a</div>',
-          created: spyA,
-          destroyed: spyAD
-        },
-        bb: {
-          template: '<div>bbb</div>',
-          created: spyB,
-          destroyed: spyBD
-        },
-        cc: {
-          template: '<div>ccc</div>',
-          created: spyC,
-          destroyed: spyCD
-        }
-      }
-    }).$mount()
-
-    assertCount([1, 0, 0, 0, 0, 0])
-    vm.n = 'bb'
-    waitForUpdate(() => {
-      assertCount([1, 0, 1, 0, 0, 0])
-      vm.n = 'cc'
-    }).then(() => {
-      // should prune A because max cache reached
-      assertCount([1, 1, 1, 0, 1, 0])
-      vm.n = 'bb'
-    }).then(() => {
-      // B should be reused, and made latest
-      assertCount([1, 1, 1, 0, 1, 0])
-      vm.n = 'aa'
-    }).then(() => {
-      // C should be pruned because B was used last so C is the oldest cached
-      assertCount([2, 1, 1, 0, 1, 1])
-    }).then(done)
-  })
-
-  it('should warn unknown component inside', () => {
-    new Vue({
-      template: `<keep-alive><foo/></keep-alive>`
-    }).$mount()
-    expect(`Unknown custom element: <foo>`).toHaveBeenWarned()
-  })
-
-  // #6938
-  it('should not cache anonymous component when include is specified', done => {
-    const Foo = {
-      name: 'foo',
-      template: `<div>foo</div>`,
-      created: jasmine.createSpy('foo')
-    }
-
-    const Bar = {
-      template: `<div>bar</div>`,
-      created: jasmine.createSpy('bar')
-    }
-
-    const Child = {
-      functional: true,
-      render (h, ctx) {
-        return h(ctx.props.view ? Foo : Bar)
-      }
-    }
-
-    const vm = new Vue({
-      template: `
-        <keep-alive include="foo">
-          <child :view="view"></child>
-        </keep-alive>
-      `,
-      data: {
-        view: true
-      },
-      components: { Child }
-    }).$mount()
-
-    function assert (foo, bar) {
-      expect(Foo.created.calls.count()).toBe(foo)
-      expect(Bar.created.calls.count()).toBe(bar)
-    }
-
-    expect(vm.$el.textContent).toBe('foo')
-    assert(1, 0)
-    vm.view = false
-    waitForUpdate(() => {
-      expect(vm.$el.textContent).toBe('bar')
-      assert(1, 1)
-      vm.view = true
-    }).then(() => {
-      expect(vm.$el.textContent).toBe('foo')
-      assert(1, 1)
-      vm.view = false
-    }).then(() => {
-      expect(vm.$el.textContent).toBe('bar')
-      assert(1, 2)
-    }).then(done)
-  })
-
-  it('should cache anonymous components if include is not specified', done => {
-    const Foo = {
-      template: `<div>foo</div>`,
-      created: jasmine.createSpy('foo')
-    }
-
-    const Bar = {
-      template: `<div>bar</div>`,
-      created: jasmine.createSpy('bar')
-    }
-
-    const Child = {
-      functional: true,
-      render (h, ctx) {
-        return h(ctx.props.view ? Foo : Bar)
-      }
-    }
-
-    const vm = new Vue({
-      template: `
-        <keep-alive>
-          <child :view="view"></child>
-        </keep-alive>
-      `,
-      data: {
-        view: true
-      },
-      components: { Child }
-    }).$mount()
-
-    function assert (foo, bar) {
-      expect(Foo.created.calls.count()).toBe(foo)
-      expect(Bar.created.calls.count()).toBe(bar)
-    }
-
-    expect(vm.$el.textContent).toBe('foo')
-    assert(1, 0)
-    vm.view = false
-    waitForUpdate(() => {
-      expect(vm.$el.textContent).toBe('bar')
-      assert(1, 1)
-      vm.view = true
-    }).then(() => {
-      expect(vm.$el.textContent).toBe('foo')
-      assert(1, 1)
-      vm.view = false
-    }).then(() => {
-      expect(vm.$el.textContent).toBe('bar')
-      assert(1, 1)
-    }).then(done)
-  })
-
-  // #7105
-  it('should not destroy active instance when pruning cache', done => {
-    const Foo = {
-      template: `<div>foo</div>`,
-      destroyed: jasmine.createSpy('destroyed')
-    }
-    const vm = new Vue({
-      template: `
-        <div>
-          <keep-alive :include="include">
-            <foo/>
-          </keep-alive>
-        </div>
-      `,
-      data: {
-        include: ['foo']
-      },
-      components: { Foo }
-    }).$mount()
-    // condition: a render where a previous component is reused
-    vm.include = ['foo']
-    waitForUpdate(() => {
-      vm.include = ['']
-    }).then(() => {
-      expect(Foo.destroyed).not.toHaveBeenCalled()
-    }).then(done)
-  })
-
-  if (!isIE9) {
-    it('with transition-mode out-in', done => {
-      let next
-      const vm = new Vue({
-        template: `<div>
-          <transition name="test" mode="out-in" @after-leave="afterLeave">
-            <keep-alive>
-              <component :is="view" class="test"></component>
-            </keep-alive>
-          </transition>
-        </div>`,
-        data: {
-          view: 'one'
-        },
-        components,
-        methods: {
-          afterLeave () {
-            next()
-          }
-        }
-      }).$mount(el)
-      expect(vm.$el.textContent).toBe('one')
-      assertHookCalls(one, [1, 1, 1, 0, 0])
-      assertHookCalls(two, [0, 0, 0, 0, 0])
-      vm.view = 'two'
-      waitForUpdate(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-leave test-leave-active">one</div><!---->'
-        )
-        assertHookCalls(one, [1, 1, 1, 1, 0])
-        assertHookCalls(two, [0, 0, 0, 0, 0])
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-leave-active test-leave-to">one</div><!---->'
-        )
-      }).thenWaitFor(_next => { next = _next }).then(() => {
-        expect(vm.$el.innerHTML).toBe('<!---->')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-enter test-enter-active">two</div>'
-        )
-        assertHookCalls(one, [1, 1, 1, 1, 0])
-        assertHookCalls(two, [1, 1, 1, 0, 0])
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-enter-active test-enter-to">two</div>'
-        )
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">two</div>'
-        )
-        assertHookCalls(one, [1, 1, 1, 1, 0])
-        assertHookCalls(two, [1, 1, 1, 0, 0])
-      }).then(() => {
-        vm.view = 'one'
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-leave test-leave-active">two</div><!---->'
-        )
-        assertHookCalls(one, [1, 1, 1, 1, 0])
-        assertHookCalls(two, [1, 1, 1, 1, 0])
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-leave-active test-leave-to">two</div><!---->'
-        )
-      }).thenWaitFor(_next => { next = _next }).then(() => {
-        expect(vm.$el.innerHTML).toBe('<!---->')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-enter test-enter-active">one</div>'
-        )
-        assertHookCalls(one, [1, 1, 2, 1, 0])
-        assertHookCalls(two, [1, 1, 1, 1, 0])
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-enter-active test-enter-to">one</div>'
-        )
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">one</div>'
-        )
-        assertHookCalls(one, [1, 1, 2, 1, 0])
-        assertHookCalls(two, [1, 1, 1, 1, 0])
-      }).then(done)
-    })
-
-    it('with transition-mode out-in + include', done => {
-      let next
-      const vm = new Vue({
-        template: `<div>
-          <transition name="test" mode="out-in" @after-leave="afterLeave">
-            <keep-alive include="one">
-              <component :is="view" class="test"></component>
-            </keep-alive>
-          </transition>
-        </div>`,
-        data: {
-          view: 'one'
-        },
-        components,
-        methods: {
-          afterLeave () {
-            next()
-          }
-        }
-      }).$mount(el)
-      expect(vm.$el.textContent).toBe('one')
-      assertHookCalls(one, [1, 1, 1, 0, 0])
-      assertHookCalls(two, [0, 0, 0, 0, 0])
-      vm.view = 'two'
-      waitForUpdate(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-leave test-leave-active">one</div><!---->'
-        )
-        assertHookCalls(one, [1, 1, 1, 1, 0])
-        assertHookCalls(two, [0, 0, 0, 0, 0])
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-leave-active test-leave-to">one</div><!---->'
-        )
-      }).thenWaitFor(_next => { next = _next }).then(() => {
-        expect(vm.$el.innerHTML).toBe('<!---->')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-enter test-enter-active">two</div>'
-        )
-        assertHookCalls(one, [1, 1, 1, 1, 0])
-        assertHookCalls(two, [1, 1, 0, 0, 0])
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-enter-active test-enter-to">two</div>'
-        )
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">two</div>'
-        )
-        assertHookCalls(one, [1, 1, 1, 1, 0])
-        assertHookCalls(two, [1, 1, 0, 0, 0])
-      }).then(() => {
-        vm.view = 'one'
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-leave test-leave-active">two</div><!---->'
-        )
-        assertHookCalls(one, [1, 1, 1, 1, 0])
-        assertHookCalls(two, [1, 1, 0, 0, 1])
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-leave-active test-leave-to">two</div><!---->'
-        )
-      }).thenWaitFor(_next => { next = _next }).then(() => {
-        expect(vm.$el.innerHTML).toBe('<!---->')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-enter test-enter-active">one</div>'
-        )
-        assertHookCalls(one, [1, 1, 2, 1, 0])
-        assertHookCalls(two, [1, 1, 0, 0, 1])
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-enter-active test-enter-to">one</div>'
-        )
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">one</div>'
-        )
-        assertHookCalls(one, [1, 1, 2, 1, 0])
-        assertHookCalls(two, [1, 1, 0, 0, 1])
-      }).then(done)
-    })
-
-    it('with transition-mode in-out', done => {
-      let next
-      const vm = new Vue({
-        template: `<div>
-          <transition name="test" mode="in-out" @after-enter="afterEnter">
-            <keep-alive>
-              <component :is="view" class="test"></component>
-            </keep-alive>
-          </transition>
-        </div>`,
-        data: {
-          view: 'one'
-        },
-        components,
-        methods: {
-          afterEnter () {
-            next()
-          }
-        }
-      }).$mount(el)
-      expect(vm.$el.textContent).toBe('one')
-      assertHookCalls(one, [1, 1, 1, 0, 0])
-      assertHookCalls(two, [0, 0, 0, 0, 0])
-      vm.view = 'two'
-      waitForUpdate(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">one</div>' +
-          '<div class="test test-enter test-enter-active">two</div>'
-        )
-        assertHookCalls(one, [1, 1, 1, 1, 0])
-        assertHookCalls(two, [1, 1, 1, 0, 0])
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">one</div>' +
-          '<div class="test test-enter-active test-enter-to">two</div>'
-        )
-      }).thenWaitFor(_next => { next = _next }).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">one</div>' +
-          '<div class="test">two</div>'
-        )
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-leave test-leave-active">one</div>' +
-          '<div class="test">two</div>'
-        )
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-leave-active test-leave-to">one</div>' +
-          '<div class="test">two</div>'
-        )
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">two</div>'
-        )
-        assertHookCalls(one, [1, 1, 1, 1, 0])
-        assertHookCalls(two, [1, 1, 1, 0, 0])
-      }).then(() => {
-        vm.view = 'one'
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">two</div>' +
-          '<div class="test test-enter test-enter-active">one</div>'
-        )
-        assertHookCalls(one, [1, 1, 2, 1, 0])
-        assertHookCalls(two, [1, 1, 1, 1, 0])
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">two</div>' +
-          '<div class="test test-enter-active test-enter-to">one</div>'
-        )
-      }).thenWaitFor(_next => { next = _next }).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">two</div>' +
-          '<div class="test">one</div>'
-        )
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-leave test-leave-active">two</div>' +
-          '<div class="test">one</div>'
-        )
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-leave-active test-leave-to">two</div>' +
-          '<div class="test">one</div>'
-        )
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">one</div>'
-        )
-        assertHookCalls(one, [1, 1, 2, 1, 0])
-        assertHookCalls(two, [1, 1, 1, 1, 0])
-      }).then(done)
-    })
-
-    it('dynamic components, in-out with early cancel', done => {
-      let next
-      const vm = new Vue({
-        template: `<div>
-          <transition name="test" mode="in-out" @after-enter="afterEnter">
-            <keep-alive>
-              <component :is="view" class="test"></component>
-            </keep-alive>
-          </transition>
-        </div>`,
-        data: { view: 'one' },
-        components,
-        methods: {
-          afterEnter () {
-            next()
-          }
-        }
-      }).$mount(el)
-      expect(vm.$el.textContent).toBe('one')
-      vm.view = 'two'
-      waitForUpdate(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">one</div>' +
-          '<div class="test test-enter test-enter-active">two</div>'
-        )
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">one</div>' +
-          '<div class="test test-enter-active test-enter-to">two</div>'
-        )
-        // switch again before enter finishes,
-        // this cancels both enter and leave.
-        vm.view = 'one'
-      }).then(() => {
-        // 1. the pending leaving "one" should be removed instantly.
-        // 2. the entering "two" should be placed into its final state instantly.
-        // 3. a new "one" is created and entering
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">two</div>' +
-          '<div class="test test-enter test-enter-active">one</div>'
-        )
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">two</div>' +
-          '<div class="test test-enter-active test-enter-to">one</div>'
-        )
-      }).thenWaitFor(_next => { next = _next }).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">two</div>' +
-          '<div class="test">one</div>'
-        )
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-leave test-leave-active">two</div>' +
-          '<div class="test">one</div>'
-        )
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-leave-active test-leave-to">two</div>' +
-          '<div class="test">one</div>'
-        )
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">one</div>'
-        )
-      }).then(done).then(done)
-    })
-
-    // #4339
-    it('component with inner transition', done => {
-      const vm = new Vue({
-        template: `
-          <div>
-            <keep-alive>
-              <component ref="test" :is="view"></component>
-            </keep-alive>
-          </div>
-        `,
-        data: { view: 'foo' },
-        components: {
-          foo: { template: '<transition><div class="test">foo</div></transition>' },
-          bar: { template: '<transition name="test"><div class="test">bar</div></transition>' }
-        }
-      }).$mount(el)
-
-      // should not apply transition on initial render by default
-      expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
-      vm.view = 'bar'
-      waitForUpdate(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test v-leave v-leave-active">foo</div>' +
-          '<div class="test test-enter test-enter-active">bar</div>'
-        )
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test v-leave-active v-leave-to">foo</div>' +
-          '<div class="test test-enter-active test-enter-to">bar</div>'
-        )
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">bar</div>'
-        )
-        vm.view = 'foo'
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-leave test-leave-active">bar</div>' +
-          '<div class="test v-enter v-enter-active">foo</div>'
-        )
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-leave-active test-leave-to">bar</div>' +
-          '<div class="test v-enter-active v-enter-to">foo</div>'
-        )
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">foo</div>'
-        )
-      }).then(done)
-    })
-
-    it('async components with transition-mode out-in', done => {
-      const barResolve = jasmine.createSpy('bar resolved')
-      let next
-      const foo = (resolve) => {
-        setTimeout(() => {
-          resolve(one)
-          Vue.nextTick(next)
-        }, duration / 2)
-      }
-      const bar = (resolve) => {
-        setTimeout(() => {
-          resolve(two)
-          barResolve()
-        }, duration / 2)
-      }
-      components = {
-        foo,
-        bar
-      }
-      const vm = new Vue({
-        template: `<div>
-          <transition name="test" mode="out-in" @after-enter="afterEnter" @after-leave="afterLeave">
-            <keep-alive>
-              <component :is="view" class="test"></component>
-            </keep-alive>
-          </transition>
-        </div>`,
-        data: {
-          view: 'foo'
-        },
-        components,
-        methods: {
-          afterEnter () {
-            next()
-          },
-          afterLeave () {
-            next()
-          }
-        }
-      }).$mount(el)
-      expect(vm.$el.textContent).toBe('')
-      next = () => {
-        assertHookCalls(one, [1, 1, 1, 0, 0])
-        assertHookCalls(two, [0, 0, 0, 0, 0])
-        waitForUpdate(() => {
-          expect(vm.$el.innerHTML).toBe(
-            '<div class="test test-enter test-enter-active">one</div>'
-          )
-        }).thenWaitFor(nextFrame).then(() => {
-          expect(vm.$el.innerHTML).toBe(
-            '<div class="test test-enter-active test-enter-to">one</div>'
-          )
-        }).thenWaitFor(_next => { next = _next }).then(() => {
-          // foo afterEnter get called
-          expect(vm.$el.innerHTML).toBe('<div class="test">one</div>')
-          vm.view = 'bar'
-        }).thenWaitFor(nextFrame).then(() => {
-          assertHookCalls(one, [1, 1, 1, 1, 0])
-          assertHookCalls(two, [0, 0, 0, 0, 0])
-          expect(vm.$el.innerHTML).toBe(
-            '<div class="test test-leave-active test-leave-to">one</div><!---->'
-          )
-        }).thenWaitFor(_next => { next = _next }).then(() => {
-          // foo afterLeave get called
-          // and bar has already been resolved before afterLeave get called
-          expect(barResolve.calls.count()).toBe(1)
-          expect(vm.$el.innerHTML).toBe('<!---->')
-        }).thenWaitFor(nextFrame).then(() => {
-          expect(vm.$el.innerHTML).toBe(
-            '<div class="test test-enter test-enter-active">two</div>'
-          )
-          assertHookCalls(one, [1, 1, 1, 1, 0])
-          assertHookCalls(two, [1, 1, 1, 0, 0])
-        }).thenWaitFor(nextFrame).then(() => {
-          expect(vm.$el.innerHTML).toBe(
-            '<div class="test test-enter-active test-enter-to">two</div>'
-          )
-        }).thenWaitFor(_next => { next = _next }).then(() => {
-          // bar afterEnter get called
-          expect(vm.$el.innerHTML).toBe('<div class="test">two</div>')
-        }).then(done)
-      }
-    })
-  }
-})
diff --git a/1.Vue/test/unit/features/component/component-scoped-slot.spec.js b/1.Vue/test/unit/features/component/component-scoped-slot.spec.js
deleted file mode 100644
index f8a0f11..0000000
--- a/1.Vue/test/unit/features/component/component-scoped-slot.spec.js
+++ /dev/null
@@ -1,1312 +0,0 @@
-import Vue from 'vue'
-
-describe('Component scoped slot', () => {
-  it('default slot', done => {
-    const vm = new Vue({
-      template: `
-        <test ref="test">
-          <template slot-scope="props">
-            <span>{{ props.msg }}</span>
-          </template>
-        </test>
-      `,
-      components: {
-        test: {
-          data () {
-            return { msg: 'hello' }
-          },
-          template: `
-            <div>
-              <slot :msg="msg"></slot>
-            </div>
-          `
-        }
-      }
-    }).$mount()
-
-    expect(vm.$el.innerHTML).toBe('<span>hello</span>')
-    vm.$refs.test.msg = 'world'
-    waitForUpdate(() => {
-      expect(vm.$el.innerHTML).toBe('<span>world</span>')
-    }).then(done)
-  })
-
-  it('default slot (plain element)', done => {
-    const vm = new Vue({
-      template: `
-        <test ref="test">
-          <span slot-scope="props">{{ props.msg }}</span>
-        </test>
-      `,
-      components: {
-        test: {
-          data () {
-            return { msg: 'hello' }
-          },
-          template: `
-            <div>
-              <slot :msg="msg"></slot>
-            </div>
-          `
-        }
-      }
-    }).$mount()
-
-    expect(vm.$el.innerHTML).toBe('<span>hello</span>')
-    vm.$refs.test.msg = 'world'
-    waitForUpdate(() => {
-      expect(vm.$el.innerHTML).toBe('<span>world</span>')
-    }).then(done)
-  })
-
-  it('with v-bind', done => {
-    const vm = new Vue({
-      template: `
-        <test ref="test">
-          <template slot-scope="props">
-            <span>{{ props.msg }} {{ props.msg2 }} {{ props.msg3 }}</span>
-          </template>
-        </test>
-      `,
-      components: {
-        test: {
-          data () {
-            return {
-              msg: 'hello',
-              obj: { msg2: 'world', msg3: '.' }
-            }
-          },
-          template: `
-            <div>
-              <slot :msg="msg" v-bind="obj" msg3="!"></slot>
-            </div>
-          `
-        }
-      }
-    }).$mount()
-
-    expect(vm.$el.innerHTML).toBe('<span>hello world !</span>')
-    vm.$refs.test.msg = 'bye'
-    vm.$refs.test.obj.msg2 = 'bye'
-    waitForUpdate(() => {
-      expect(vm.$el.innerHTML).toBe('<span>bye bye !</span>')
-    }).then(done)
-  })
-
-  it('should warn when using v-bind with no object', () => {
-    new Vue({
-      template: `
-        <test ref="test">
-          <template scope="props">
-          </template>
-        </test>
-      `,
-      components: {
-        test: {
-          data () {
-            return {
-              text: 'some text'
-            }
-          },
-          template: `
-            <div>
-              <slot v-bind="text"></slot>
-            </div>
-          `
-        }
-      }
-    }).$mount()
-    expect('slot v-bind without argument expects an Object').toHaveBeenWarned()
-  })
-
-  it('should not warn when using v-bind with object', () => {
-    new Vue({
-      template: `
-        <test ref="test">
-          <template scope="props">
-          </template>
-        </test>
-      `,
-      components: {
-        test: {
-          data () {
-            return {
-              foo: {
-                text: 'some text'
-              }
-            }
-          },
-          template: `
-            <div>
-              <slot v-bind="foo"></slot>
-            </div>
-          `
-        }
-      }
-    }).$mount()
-    expect('slot v-bind without argument expects an Object').not.toHaveBeenWarned()
-  })
-
-  it('named scoped slot', done => {
-    const vm = new Vue({
-      template: `
-        <test ref="test">
-          <template slot="item" slot-scope="props">
-            <span>{{ props.foo }}</span><span>{{ props.bar }}</span>
-          </template>
-        </test>
-      `,
-      components: {
-        test: {
-          data () {
-            return { foo: 'FOO', bar: 'BAR' }
-          },
-          template: `
-            <div>
-              <slot name="item" :foo="foo" :bar="bar"></slot>
-            </div>
-          `
-        }
-      }
-    }).$mount()
-
-    expect(vm.$el.innerHTML).toBe('<span>FOO</span><span>BAR</span>')
-    vm.$refs.test.foo = 'BAZ'
-    waitForUpdate(() => {
-      expect(vm.$el.innerHTML).toBe('<span>BAZ</span><span>BAR</span>')
-    }).then(done)
-  })
-
-  it('named scoped slot (plain element)', done => {
-    const vm = new Vue({
-      template: `
-        <test ref="test">
-          <span slot="item" slot-scope="props">{{ props.foo }} {{ props.bar }}</span>
-        </test>
-      `,
-      components: {
-        test: {
-          data () {
-            return { foo: 'FOO', bar: 'BAR' }
-          },
-          template: `
-            <div>
-              <slot name="item" :foo="foo" :bar="bar"></slot>
-            </div>
-          `
-        }
-      }
-    }).$mount()
-
-    expect(vm.$el.innerHTML).toBe('<span>FOO BAR</span>')
-    vm.$refs.test.foo = 'BAZ'
-    waitForUpdate(() => {
-      expect(vm.$el.innerHTML).toBe('<span>BAZ BAR</span>')
-    }).then(done)
-  })
-
-  it('fallback content', () => {
-    const vm = new Vue({
-      template: `<test></test>`,
-      components: {
-        test: {
-          data () {
-            return { msg: 'hello' }
-          },
-          template: `
-            <div>
-              <slot name="item" :text="msg">
-                <span>{{ msg }} fallback</span>
-              </slot>
-            </div>
-          `
-        }
-      }
-    }).$mount()
-    expect(vm.$el.innerHTML).toBe('<span>hello fallback</span>')
-  })
-
-  it('slot with v-for', done => {
-    const vm = new Vue({
-      template: `
-        <test ref="test">
-          <template slot="item" slot-scope="props">
-            <span>{{ props.text }}</span>
-          </template>
-        </test>
-      `,
-      components: {
-        test: {
-          data () {
-            return {
-              items: ['foo', 'bar', 'baz']
-            }
-          },
-          template: `
-            <div>
-              <slot v-for="item in items" name="item" :text="item"></slot>
-            </div>
-          `
-        }
-      }
-    }).$mount()
-
-    function assertOutput () {
-      expect(vm.$el.innerHTML).toBe(vm.$refs.test.items.map(item => {
-        return `<span>${item}</span>`
-      }).join(''))
-    }
-
-    assertOutput()
-    vm.$refs.test.items.reverse()
-    waitForUpdate(assertOutput).then(() => {
-      vm.$refs.test.items.push('qux')
-    }).then(assertOutput).then(done)
-  })
-
-  it('slot inside v-for', done => {
-    const vm = new Vue({
-      template: `
-        <test ref="test">
-          <template slot="item" slot-scope="props">
-            <span>{{ props.text }}</span>
-          </template>
-        </test>
-      `,
-      components: {
-        test: {
-          data () {
-            return {
-              items: ['foo', 'bar', 'baz']
-            }
-          },
-          template: `
-            <ul>
-              <li v-for="item in items">
-                <slot name="item" :text="item"></slot>
-              </li>
-            </ul>
-          `
-        }
-      }
-    }).$mount()
-
-    function assertOutput () {
-      expect(vm.$el.innerHTML).toBe(vm.$refs.test.items.map(item => {
-        return `<li><span>${item}</span></li>`
-      }).join(''))
-    }
-
-    assertOutput()
-    vm.$refs.test.items.reverse()
-    waitForUpdate(assertOutput).then(() => {
-      vm.$refs.test.items.push('qux')
-    }).then(assertOutput).then(done)
-  })
-
-  it('scoped slot without scope alias', () => {
-    const vm = new Vue({
-      template: `
-        <test ref="test">
-          <span slot="item">I am static</span>
-        </test>
-      `,
-      components: {
-        test: {
-          data () {
-            return { msg: 'hello' }
-          },
-          template: `
-            <div>
-              <slot name="item" :text="msg"></slot>
-            </div>
-          `
-        }
-      }
-    }).$mount()
-    expect(vm.$el.innerHTML).toBe('<span>I am static</span>')
-  })
-
-  it('non-scoped slot with scope alias', () => {
-    const vm = new Vue({
-      template: `
-        <test ref="test">
-          <template slot="item" slot-scope="props">
-            <span>{{ props.text || 'meh' }}</span>
-          </template>
-        </test>
-      `,
-      components: {
-        test: {
-          data () {
-            return { msg: 'hello' }
-          },
-          template: `
-            <div>
-              <slot name="item"></slot>
-            </div>
-          `
-        }
-      }
-    }).$mount()
-    expect(vm.$el.innerHTML).toBe('<span>meh</span>')
-  })
-
-  it('warn key on slot', () => {
-    new Vue({
-      template: `
-        <test ref="test">
-          <template slot="item" slot-scope="props">
-            <span>{{ props.text }}</span>
-          </template>
-        </test>
-      `,
-      components: {
-        test: {
-          data () {
-            return {
-              items: ['foo', 'bar', 'baz']
-            }
-          },
-          template: `
-            <div>
-              <slot v-for="item in items" name="item" :text="item" :key="item"></slot>
-            </div>
-          `
-        }
-      }
-    }).$mount()
-    expect(`\`key\` does not work on <slot>`).toHaveBeenWarned()
-  })
-
-  it('render function usage (named, via data)', done => {
-    const vm = new Vue({
-      render (h) {
-        return h('test', {
-          ref: 'test',
-          scopedSlots: {
-            item: props => h('span', props.text)
-          }
-        })
-      },
-      components: {
-        test: {
-          data () {
-            return { msg: 'hello' }
-          },
-          render (h) {
-            return h('div', this.$scopedSlots.item({
-              text: this.msg
-            }))
-          }
-        }
-      }
-    }).$mount()
-
-    expect(vm.$el.innerHTML).toBe('<span>hello</span>')
-    vm.$refs.test.msg = 'world'
-    waitForUpdate(() => {
-      expect(vm.$el.innerHTML).toBe('<span>world</span>')
-    }).then(done)
-  })
-
-  it('render function usage (default, as children)', () => {
-    const vm = new Vue({
-      render (h) {
-        return h('test', [
-          props => h('span', [props.msg])
-        ])
-      },
-      components: {
-        test: {
-          data () {
-            return { msg: 'hello' }
-          },
-          render (h) {
-            return h('div', this.$scopedSlots.default({ msg: this.msg }))
-          }
-        }
-      }
-    }).$mount()
-    expect(vm.$el.innerHTML).toBe('<span>hello</span>')
-  })
-
-  it('render function usage (default, as root)', () => {
-    const vm = new Vue({
-      render (h) {
-        return h('test', [
-          props => h('span', [props.msg])
-        ])
-      },
-      components: {
-        test: {
-          data () {
-            return { msg: 'hello' }
-          },
-          render (h) {
-            const res = this.$scopedSlots.default({ msg: this.msg })
-            // all scoped slots should be normalized into arrays
-            expect(Array.isArray(res)).toBe(true)
-            return res
-          }
-        }
-      }
-    }).$mount()
-    expect(vm.$el.outerHTML).toBe('<span>hello</span>')
-  })
-
-  // new in 2.6, unifying all slots as functions
-  it('non-scoped slots should also be available on $scopedSlots', () => {
-    const vm = new Vue({
-      template: `<foo>before <div slot="bar" slot-scope="scope">{{ scope.msg }}</div> after</foo>`,
-      components: {
-        foo: {
-          render(h) {
-            return h('div', [
-              this.$scopedSlots.default(),
-              this.$scopedSlots.bar({ msg: 'hi' })
-            ])
-          }
-        }
-      }
-    }).$mount()
-    expect(vm.$el.innerHTML).toBe(`before  after<div>hi</div>`)
-  })
-
-  // #4779
-  it('should support dynamic slot target', done => {
-    const Child = {
-      template: `
-        <div>
-          <slot name="a" msg="a" />
-          <slot name="b" msg="b" />
-        </div>
-      `
-    }
-
-    const vm = new Vue({
-      data: {
-        a: 'a',
-        b: 'b'
-      },
-      template: `
-        <child>
-          <template :slot="a" slot-scope="props">A {{ props.msg }}</template>
-          <template :slot="b" slot-scope="props">B {{ props.msg }}</template>
-        </child>
-      `,
-      components: { Child }
-    }).$mount()
-
-    expect(vm.$el.textContent.trim()).toBe('A a B b')
-
-    // switch slots
-    vm.a = 'b'
-    vm.b = 'a'
-    waitForUpdate(() => {
-      expect(vm.$el.textContent.trim()).toBe('B a A b')
-    }).then(done)
-  })
-
-  it('render function usage (JSX)', () => {
-    const vm = new Vue({
-      render (h) {
-        return <test>{
-          props => <span>{props.msg}</span>
-        }</test>
-      },
-      components: {
-        test: {
-          data () {
-            return { msg: 'hello' }
-          },
-          render (h) {
-            return <div>
-              {this.$scopedSlots.default({ msg: this.msg })}
-            </div>
-          }
-        }
-      }
-    }).$mount()
-    expect(vm.$el.innerHTML).toBe('<span>hello</span>')
-  })
-
-  // #5615
-  it('scoped slot with v-for', done => {
-    const vm = new Vue({
-      data: { names: ['foo', 'bar'] },
-      template: `
-        <test ref="test">
-          <template v-for="n in names" :slot="n" slot-scope="props">
-            <span>{{ props.msg }}</span>
-          </template>
-          <template slot="abc" slot-scope="props">
-            <span>{{ props.msg }}</span>
-          </template>
-        </test>
-      `,
-      components: {
-        test: {
-          data: () => ({ msg: 'hello' }),
-          template: `
-            <div>
-              <slot name="foo" :msg="msg + ' foo'"></slot>
-              <slot name="bar" :msg="msg + ' bar'"></slot>
-              <slot name="abc" :msg="msg + ' abc'"></slot>
-            </div>
-          `
-        }
-      }
-    }).$mount()
-
-    expect(vm.$el.innerHTML).toBe('<span>hello foo</span> <span>hello bar</span> <span>hello abc</span>')
-    vm.$refs.test.msg = 'world'
-    waitForUpdate(() => {
-      expect(vm.$el.innerHTML).toBe('<span>world foo</span> <span>world bar</span> <span>world abc</span>')
-    }).then(done)
-  })
-
-  it('scoped slot with v-for (plain elements)', done => {
-    const vm = new Vue({
-      data: { names: ['foo', 'bar'] },
-      template: `
-        <test ref="test">
-          <span v-for="n in names" :slot="n" slot-scope="props">{{ props.msg }}</span>
-          <span slot="abc" slot-scope="props">{{ props.msg }}</span>
-        </test>
-      `,
-      components: {
-        test: {
-          data: () => ({ msg: 'hello' }),
-          template: `
-            <div>
-              <slot name="foo" :msg="msg + ' foo'"></slot>
-              <slot name="bar" :msg="msg + ' bar'"></slot>
-              <slot name="abc" :msg="msg + ' abc'"></slot>
-            </div>
-          `
-        }
-      }
-    }).$mount()
-
-    expect(vm.$el.innerHTML).toBe('<span>hello foo</span> <span>hello bar</span> <span>hello abc</span>')
-    vm.$refs.test.msg = 'world'
-    waitForUpdate(() => {
-      expect(vm.$el.innerHTML).toBe('<span>world foo</span> <span>world bar</span> <span>world abc</span>')
-    }).then(done)
-  })
-
-  // #6725
-  it('scoped slot with v-if', done => {
-    const vm = new Vue({
-      data: {
-        ok: false
-      },
-      template: `
-        <test>
-          <template v-if="ok" slot-scope="foo">
-            <p>{{ foo.text }}</p>
-          </template>
-        </test>
-      `,
-      components: {
-        test: {
-          data () {
-            return { msg: 'hello' }
-          },
-          template: `
-            <div>
-              <slot :text="msg">
-                <span>{{ msg }} fallback</span>
-              </slot>
-            </div>
-          `
-        }
-      }
-    }).$mount()
-    expect(vm.$el.innerHTML).toBe('<span>hello fallback</span>')
-
-    vm.ok = true
-    waitForUpdate(() => {
-      expect(vm.$el.innerHTML).toBe('<p>hello</p>')
-    }).then(done)
-  })
-
-  // #9422
-  // the behavior of the new syntax is slightly different.
-  it('scoped slot v-if using slot-scope value', () => {
-    const Child = {
-      template: '<div><slot value="foo"/></div>',
-    }
-    const vm = new Vue({
-      components: { Child },
-      template: `
-        <child>
-          <template slot-scope="{ value }" v-if="value">
-            foo {{ value }}
-          </template>
-        </child>
-      `
-    }).$mount()
-    expect(vm.$el.textContent).toMatch(`foo foo`)
-  })
-
-  // 2.6 new slot syntax
-  describe('v-slot syntax', () => {
-    const Foo = {
-      render(h) {
-        return h('div', [
-          this.$scopedSlots.default && this.$scopedSlots.default('from foo default'),
-          this.$scopedSlots.one && this.$scopedSlots.one('from foo one'),
-          this.$scopedSlots.two && this.$scopedSlots.two('from foo two')
-        ])
-      }
-    }
-
-    const Bar = {
-      render(h) {
-        return this.$scopedSlots.default && this.$scopedSlots.default('from bar')
-      }
-    }
-
-    const Baz = {
-      render(h) {
-        return this.$scopedSlots.default && this.$scopedSlots.default('from baz')
-      }
-    }
-
-    const toNamed = (syntax, name) => syntax[0] === '#'
-      ? `#${name}` // shorthand
-      : `${syntax}:${name}` // full syntax
-
-    function runSuite(syntax) {
-      it('default slot', () => {
-        const vm = new Vue({
-          template: `<foo ${syntax}="foo">{{ foo }}<div>{{ foo }}</div></foo>`,
-          components: { Foo }
-        }).$mount()
-        expect(vm.$el.innerHTML).toBe(`from foo default<div>from foo default</div>`)
-      })
-
-      it('nested default slots', () => {
-        const vm = new Vue({
-          template: `
-            <foo ${syntax}="foo">
-              <bar ${syntax}="bar">
-                <baz ${syntax}="baz">
-                  {{ foo }} | {{ bar }} | {{ baz }}
-                </baz>
-              </bar>
-            </foo>
-          `,
-          components: { Foo, Bar, Baz }
-        }).$mount()
-        expect(vm.$el.innerHTML.trim()).toBe(`from foo default | from bar | from baz`)
-      })
-
-      it('named slots', () => {
-        const vm = new Vue({
-          template: `
-            <foo>
-              <template ${toNamed(syntax, 'default')}="foo">
-                {{ foo }}
-              </template>
-              <template ${toNamed(syntax, 'one')}="one">
-                {{ one }}
-              </template>
-              <template ${toNamed(syntax, 'two')}="two">
-                {{ two }}
-              </template>
-            </foo>
-          `,
-          components: { Foo }
-        }).$mount()
-        expect(vm.$el.innerHTML.replace(/\s+/g, ' ')).toMatch(`from foo default from foo one from foo two`)
-      })
-
-      it('nested + named + default slots', () => {
-        const vm = new Vue({
-          template: `
-            <foo>
-              <template ${toNamed(syntax, 'one')}="one">
-                <bar ${syntax}="bar">
-                  {{ one }} {{ bar }}
-                </bar>
-              </template>
-              <template ${toNamed(syntax, 'two')}="two">
-                <baz ${syntax}="baz">
-                  {{ two }} {{ baz }}
-                </baz>
-              </template>
-            </foo>
-          `,
-          components: { Foo, Bar, Baz }
-        }).$mount()
-        expect(vm.$el.innerHTML.replace(/\s+/g, ' ')).toMatch(`from foo one from bar from foo two from baz`)
-      })
-
-      it('should warn v-slot usage on non-component elements', () => {
-        const vm = new Vue({
-          template: `<div ${syntax}="foo"/>`
-        }).$mount()
-        expect(`v-slot can only be used on components or <template>`).toHaveBeenWarned()
-      })
-
-      it('should warn mixed usage', () => {
-        const vm = new Vue({
-          template: `<foo><bar slot="one" slot-scope="bar" ${syntax}="bar"></bar></foo>`,
-          components: { Foo, Bar }
-        }).$mount()
-        expect(`Unexpected mixed usage of different slot syntaxes`).toHaveBeenWarned()
-      })
-    }
-
-    // run tests for both full syntax and shorthand
-    runSuite('v-slot')
-    runSuite('#default')
-
-    it('shorthand named slots', () => {
-      const vm = new Vue({
-        template: `
-          <foo>
-            <template #default="foo">
-              {{ foo }}
-            </template>
-            <template #one="one">
-              {{ one }}
-            </template>
-            <template #two="two">
-              {{ two }}
-            </template>
-          </foo>
-        `,
-        components: { Foo }
-      }).$mount()
-      expect(vm.$el.innerHTML.replace(/\s+/g, ' ')).toMatch(`from foo default from foo one from foo two`)
-    })
-
-    it('should warn mixed root-default and named slots', () => {
-      const vm = new Vue({
-        template: `
-          <foo #default="foo">
-            {{ foo }}
-            <template #one="one">
-              {{ one }}
-            </template>
-          </foo>
-        `,
-        components: { Foo }
-      }).$mount()
-      expect(`default slot should also use <template>`).toHaveBeenWarned()
-    })
-
-    it('shorthand without scope variable', () => {
-      const vm = new Vue({
-        template: `
-          <foo>
-            <template #one>one</template>
-            <template #two>two</template>
-          </foo>
-        `,
-        components: { Foo }
-      }).$mount()
-      expect(vm.$el.innerHTML.replace(/\s+/g, ' ')).toMatch(`onetwo`)
-    })
-
-    it('shorthand named slots on root', () => {
-      const vm = new Vue({
-        template: `
-          <foo #one="one">
-            {{ one }}
-          </foo>
-        `,
-        components: { Foo }
-      }).$mount()
-      expect(vm.$el.innerHTML.replace(/\s+/g, ' ')).toMatch(`from foo one`)
-    })
-
-    it('dynamic slot name', done => {
-      const vm = new Vue({
-        data: {
-          a: 'one',
-          b: 'two'
-        },
-        template: `
-          <foo>
-            <template #[a]="one">a {{ one }} </template>
-            <template v-slot:[b]="two">b {{ two }} </template>
-          </foo>
-        `,
-        components: { Foo }
-      }).$mount()
-      expect(vm.$el.innerHTML.replace(/\s+/g, ' ')).toMatch(`a from foo one b from foo two`)
-      vm.a = 'two'
-      vm.b = 'one'
-      waitForUpdate(() => {
-        expect(vm.$el.innerHTML.replace(/\s+/g, ' ')).toMatch(`b from foo one a from foo two `)
-      }).then(done)
-    })
-
-    it('should work with v-if/v-else', done => {
-      const vm = new Vue({
-        data: { flag: true },
-        template: `
-          <foo>
-            <template v-if="flag" v-slot:one="one">a {{ one }} </template>
-            <template v-else v-slot:two="two">b {{ two }} </template>
-          </foo>
-        `,
-        components: { Foo }
-      }).$mount()
-      expect(vm.$el.innerHTML).toBe(`a from foo one `)
-      vm.flag = false
-      waitForUpdate(() => {
-        expect(vm.$el.innerHTML).toBe(`b from foo two `)
-      }).then(done)
-    })
-
-    it('warn when v-slot used on non-root <template>', () => {
-      const vm = new Vue({
-        template: `
-          <foo>
-            <template v-if="true">
-              <template v-slot:one>foo</template>
-            </template>
-          </foo>
-        `,
-        components: { Foo }
-      }).$mount()
-      expect(`<template v-slot> can only appear at the root level`).toHaveBeenWarned()
-    })
-  })
-
-  // 2.6 scoped slot perf optimization
-  it('should have accurate tracking for scoped slots', done => {
-    const parentUpdate = jasmine.createSpy()
-    const childUpdate = jasmine.createSpy()
-    const vm = new Vue({
-      template: `
-        <div>{{ parentCount }}<foo #default>{{ childCount }}</foo></div>
-      `,
-      data: {
-        parentCount: 0,
-        childCount: 0
-      },
-      updated: parentUpdate,
-      components: {
-        foo: {
-          template: `<div><slot/></div>`,
-          updated: childUpdate
-        }
-      }
-    }).$mount()
-    expect(vm.$el.innerHTML).toMatch(`0<div>0</div>`)
-
-    vm.parentCount++
-    waitForUpdate(() => {
-      expect(vm.$el.innerHTML).toMatch(`1<div>0</div>`)
-      // should only trigger parent update
-      expect(parentUpdate.calls.count()).toBe(1)
-      expect(childUpdate.calls.count()).toBe(0)
-
-      vm.childCount++
-    }).then(() => {
-      expect(vm.$el.innerHTML).toMatch(`1<div>1</div>`)
-      // should only trigger child update
-      expect(parentUpdate.calls.count()).toBe(1)
-      expect(childUpdate.calls.count()).toBe(1)
-    }).then(done)
-  })
-
-  // #9432: async components inside a scoped slot should trigger update of the
-  // component that invoked the scoped slot, not the lexical context component.
-  it('async component inside scoped slot', done => {
-    let p
-    const vm = new Vue({
-      template: `
-        <foo>
-          <template #default>
-            <bar />
-          </template>
-        </foo>
-      `,
-      components: {
-        foo: {
-          template: `<div>foo<slot/></div>`
-        },
-        bar: resolve => {
-          setTimeout(() => {
-            resolve({
-              template: `<div>bar</div>`
-            })
-            next()
-          }, 0)
-        }
-      }
-    }).$mount()
-
-    function next () {
-      waitForUpdate(() => {
-        expect(vm.$el.textContent).toBe(`foobar`)
-      }).then(done)
-    }
-  })
-
-  // regression #9396
-  it('should not force update child with no slot content', done => {
-    const Child = {
-      updated: jasmine.createSpy(),
-      template: `<div></div>`
-    }
-
-    const parent = new Vue({
-      template: `<div>{{ count }}<child/></div>`,
-      data: {
-        count: 0
-      },
-      components: { Child }
-    }).$mount()
-
-    expect(parent.$el.textContent).toBe(`0`)
-    parent.count++
-    waitForUpdate(() => {
-      expect(parent.$el.textContent).toBe(`1`)
-      expect(Child.updated).not.toHaveBeenCalled()
-    }).then(done)
-  })
-
-  // regression #9438
-  it('nested scoped slots update', done => {
-    const Wrapper = {
-      template: `<div><slot/></div>`
-    }
-
-    const Inner = {
-      props: ['foo'],
-      template: `<div>{{ foo }}</div>`
-    }
-
-    const Outer = {
-      data: () => ({ foo: 1 }),
-      template: `<div><slot :foo="foo" /></div>`
-    }
-
-    const vm = new Vue({
-      components: { Outer, Wrapper, Inner },
-      template: `
-        <outer ref="outer" v-slot="props">
-          <wrapper v-slot>
-            <inner :foo="props.foo"/>
-          </wrapper>
-        </outer>
-      `
-    }).$mount()
-
-    expect(vm.$el.textContent).toBe(`1`)
-
-    vm.$refs.outer.foo++
-    waitForUpdate(() => {
-      expect(vm.$el.textContent).toBe(`2`)
-    }).then(done)
-  })
-
-  it('dynamic v-bind arguments on <slot>', done => {
-    const Foo = {
-      data() {
-        return {
-          key: 'msg'
-        }
-      },
-      template: `<div><slot :[key]="'hello'"/></div>`
-    }
-
-    const vm = new Vue({
-      components: { Foo },
-      template: `
-        <foo ref="foo" v-slot="props">{{ props }}</foo>
-      `
-    }).$mount()
-
-    expect(vm.$el.textContent).toBe(JSON.stringify({ msg: 'hello' }, null, 2))
-
-    vm.$refs.foo.key = 'changed'
-    waitForUpdate(() => {
-      expect(vm.$el.textContent).toBe(JSON.stringify({ changed: 'hello' }, null, 2))
-    }).then(done)
-  })
-
-  // #9452
-  it('fallback for scoped slots passed multiple levels down', () => {
-    const inner = {
-      template: `<div><slot>fallback</slot></div>`
-    }
-
-    const wrapper = {
-      template: `
-        <inner>
-          <template #default>
-            <slot/>
-          </template>
-        </inner>
-      `,
-      components: { inner }
-    }
-
-    const vm = new Vue({
-      components: { wrapper, inner },
-      template: `<wrapper/>`
-    }).$mount()
-
-    expect(vm.$el.textContent).toBe(`fallback`)
-  })
-
-  it('should expose v-slot without scope on this.$slots', () => {
-    const vm = new Vue({
-      template: `<foo><template v-slot>hello</template></foo>`,
-      components: {
-        foo: {
-          render(h) {
-            return h('div', this.$slots.default)
-          }
-        }
-      }
-    }).$mount()
-    expect(vm.$el.textContent).toBe('hello')
-  })
-
-  it('should not expose legacy syntax scoped slot on this.$slots', () => {
-    const vm = new Vue({
-      template: `<foo><template slot-scope="foo">hello</template></foo>`,
-      components: {
-        foo: {
-          render(h) {
-            expect(this.$slots.default).toBeUndefined()
-            return h('div', this.$slots.default)
-          }
-        }
-      }
-    }).$mount()
-    expect(vm.$el.textContent).toBe('')
-  })
-
-  it('should expose v-slot without scope on ctx.slots() in functional', () => {
-    const vm = new Vue({
-      template: `<foo><template v-slot>hello</template></foo>`,
-      components: {
-        foo: {
-          functional: true,
-          render(h, ctx) {
-            return h('div', ctx.slots().default)
-          }
-        }
-      }
-    }).$mount()
-    expect(vm.$el.textContent).toBe('hello')
-  })
-
-  it('should not cache scoped slot normalization when there are a mix of normal and scoped slots', done => {
-    const foo = {
-      template: `<div><slot name="foo" /> <slot name="bar" /></div>`
-    }
-
-    const vm = new Vue({
-      data: {
-        msg: 'foo'
-      },
-      template: `
-        <foo>
-          <div slot="foo">{{ msg }}</div>
-          <template #bar><div>bar</div></template>
-        </foo>
-      `,
-      components: { foo }
-    }).$mount()
-
-    expect(vm.$el.textContent).toBe(`foo bar`)
-    vm.msg = 'baz'
-    waitForUpdate(() => {
-      expect(vm.$el.textContent).toBe(`baz bar`)
-    }).then(done)
-  })
-
-  // #9468
-  it('should support passing multiple args to scoped slot function', () => {
-    const foo = {
-      render() {
-        return this.$scopedSlots.default('foo', 'bar')
-      }
-    }
-
-    const vm = new Vue({
-      template: `<foo v-slot="foo, bar">{{ foo }} {{ bar }}</foo>`,
-      components: { foo }
-    }).$mount()
-
-    expect(vm.$el.textContent).toBe('foo bar')
-  })
-
-  it('should not skip updates when a scoped slot contains parent <slot/> content', done => {
-    const inner = {
-      template: `<div><slot/></div>`
-    }
-
-    const wrapper = {
-      template: `<inner v-slot><slot/></inner>`,
-      components: { inner }
-    }
-
-    const vm = new Vue({
-      data() {
-        return {
-          ok: true
-        }
-      },
-      components: { wrapper },
-      template: `<wrapper><div>{{ ok ? 'foo' : 'bar' }}</div></wrapper>`
-    }).$mount()
-
-    expect(vm.$el.textContent).toBe('foo')
-    vm.ok = false
-    waitForUpdate(() => {
-      expect(vm.$el.textContent).toBe('bar')
-    }).then(done)
-  })
-
-  it('should not skip updates for v-slot inside v-for', done => {
-    const test = {
-      template: `<div><slot></slot></div>`
-    }
-
-    const vm = new Vue({
-      template: `
-      <div>
-        <div v-for="i in numbers">
-          <test v-slot>{{ i }}</test>
-        </div>
-      </div>
-      `,
-      components: { test },
-      data: {
-        numbers: [1]
-      }
-    }).$mount()
-
-    expect(vm.$el.textContent).toBe(`1`)
-    vm.numbers = [2]
-    waitForUpdate(() => {
-      expect(vm.$el.textContent).toBe(`2`)
-    }).then(done)
-  })
-
-  // #9534
-  it('should detect conditional reuse with different slot content', done => {
-    const Foo = {
-      template: `<div><slot :n="1" /></div>`
-    }
-
-    const vm = new Vue({
-      components: { Foo },
-      data: {
-        ok: true
-      },
-      template: `
-        <div>
-          <div v-if="ok">
-            <foo v-slot="{ n }">{{ n }}</foo>
-          </div>
-          <div v-if="!ok">
-            <foo v-slot="{ n }">{{ n + 1 }}</foo>
-          </div>
-        </div>
-      `
-    }).$mount()
-
-    expect(vm.$el.textContent.trim()).toBe(`1`)
-    vm.ok = false
-    waitForUpdate(() => {
-      expect(vm.$el.textContent.trim()).toBe(`2`)
-    }).then(done)
-  })
-
-  // #9644
-  it('should factor presence of normal slots into scoped slots caching', done => {
-    const Wrapper = {
-      template: `<div>
-        <p>Default:<slot/></p>
-        <p>Content:<slot name='content'/></p>
-      </div>`
-    }
-
-    const vm = new Vue({
-      data: { ok: false },
-      components: { Wrapper },
-      template: `<wrapper>
-        <p v-if='ok'>ok</p>
-        <template #content>
-          <p v-if='ok'>ok</p>
-        </template>
-      </wrapper>`
-    }).$mount()
-
-    expect(vm.$el.textContent).not.toMatch(`Default:ok`)
-    expect(vm.$el.textContent).not.toMatch(`Content:ok`)
-    vm.ok = true
-    waitForUpdate(() => {
-      expect(vm.$el.textContent).toMatch(`Default:ok`)
-      expect(vm.$el.textContent).toMatch(`Content:ok`)
-      vm.ok = false
-    }).then(() => {
-      expect(vm.$el.textContent).not.toMatch(`Default:ok`)
-      expect(vm.$el.textContent).not.toMatch(`Content:ok`)
-      vm.ok = true
-    }).then(() => {
-      expect(vm.$el.textContent).toMatch(`Default:ok`)
-      expect(vm.$el.textContent).toMatch(`Content:ok`)
-    }).then(done)
-  })
-
-  //#9658
-  it('fallback for scoped slot with single v-if', () => {
-    const vm = new Vue({
-      template: `<test v-slot><template v-if="false">hi</template></test>`,
-      components: {
-        Test: {
-          template: `<div><slot>fallback</slot></div>`
-        }
-      }
-    }).$mount()
-    expect(vm.$el.textContent).toMatch('fallback')
-  })
-
-  // #9699
-  // Component only has normal slots, but is passing down $scopedSlots directly
-  // $scopedSlots should not be marked as stable in this case
-  it('render function passing $scopedSlots w/ normal slots down', done => {
-    const one = {
-      template: `<div><slot name="footer"/></div>`
-    }
-
-    const two = {
-      render(h) {
-        return h(one, {
-          scopedSlots: this.$scopedSlots
-        })
-      }
-    }
-
-    const vm = new Vue({
-      data: { count: 0 },
-      render(h) {
-        return h(two, [
-          h('span', { slot: 'footer' }, this.count)
-        ])
-      }
-    }).$mount()
-
-    expect(vm.$el.textContent).toMatch(`0`)
-    vm.count++
-    waitForUpdate(() => {
-      expect(vm.$el.textContent).toMatch(`1`)
-    }).then(done)
-  })
-})
diff --git a/1.Vue/test/unit/features/component/component-slot.spec.js b/1.Vue/test/unit/features/component/component-slot.spec.js
deleted file mode 100644
index 3e5fa88..0000000
--- a/1.Vue/test/unit/features/component/component-slot.spec.js
+++ /dev/null
@@ -1,948 +0,0 @@
-import Vue from 'vue'
-
-describe('Component slot', () => {
-  let vm, child
-  function mount (options) {
-    vm = new Vue({
-      data: {
-        msg: 'parent message'
-      },
-      template: `<div><test>${options.parentContent || ''}</test></div>`,
-      components: {
-        test: {
-          template: options.childTemplate,
-          data () {
-            return {
-              msg: 'child message'
-            }
-          }
-        }
-      }
-    }).$mount()
-    child = vm.$children[0]
-  }
-
-  it('no content', () => {
-    mount({
-      childTemplate: '<div><slot></slot></div>'
-    })
-    expect(child.$el.childNodes.length).toBe(0)
-  })
-
-  it('default slot', done => {
-    mount({
-      childTemplate: '<div><slot></slot></div>',
-      parentContent: '<p>{{ msg }}</p>'
-    })
-    expect(child.$el.tagName).toBe('DIV')
-    expect(child.$el.children[0].tagName).toBe('P')
-    expect(child.$el.children[0].textContent).toBe('parent message')
-    vm.msg = 'changed'
-    waitForUpdate(() => {
-      expect(child.$el.children[0].textContent).toBe('changed')
-    }).then(done)
-  })
-
-  it('named slot', done => {
-    mount({
-      childTemplate: '<div><slot name="test"></slot></div>',
-      parentContent: '<p slot="test">{{ msg }}</p>'
-    })
-    expect(child.$el.tagName).toBe('DIV')
-    expect(child.$el.children[0].tagName).toBe('P')
-    expect(child.$el.children[0].textContent).toBe('parent message')
-    vm.msg = 'changed'
-    waitForUpdate(() => {
-      expect(child.$el.children[0].textContent).toBe('changed')
-    }).then(done)
-  })
-
-  it('named slot with 0 as a number', done => {
-    mount({
-      childTemplate: '<div><slot :name="0"></slot></div>',
-      parentContent: '<p :slot="0">{{ msg }}</p>'
-    })
-    expect(child.$el.tagName).toBe('DIV')
-    expect(child.$el.children[0].tagName).toBe('P')
-    expect(child.$el.children[0].textContent).toBe('parent message')
-    vm.msg = 'changed'
-    waitForUpdate(() => {
-      expect(child.$el.children[0].textContent).toBe('changed')
-    }).then(done)
-  })
-
-  it('fallback content', () => {
-    mount({
-      childTemplate: '<div><slot><p>{{msg}}</p></slot></div>'
-    })
-    expect(child.$el.children[0].tagName).toBe('P')
-    expect(child.$el.textContent).toBe('child message')
-  })
-
-  it('fallback content with multiple named slots', () => {
-    mount({
-      childTemplate: `
-        <div>
-          <slot name="a"><p>fallback a</p></slot>
-          <slot name="b">fallback b</slot>
-        </div>
-      `,
-      parentContent: '<p slot="b">slot b</p>'
-    })
-    expect(child.$el.children.length).toBe(2)
-    expect(child.$el.children[0].textContent).toBe('fallback a')
-    expect(child.$el.children[1].textContent).toBe('slot b')
-  })
-
-  it('fallback content with mixed named/unnamed slots', () => {
-    mount({
-      childTemplate: `
-        <div>
-          <slot><p>fallback a</p></slot>
-          <slot name="b">fallback b</slot>
-        </div>
-      `,
-      parentContent: '<p slot="b">slot b</p>'
-    })
-    expect(child.$el.children.length).toBe(2)
-    expect(child.$el.children[0].textContent).toBe('fallback a')
-    expect(child.$el.children[1].textContent).toBe('slot b')
-  })
-
-  it('selector matching multiple elements', () => {
-    mount({
-      childTemplate: '<div><slot name="t"></slot></div>',
-      parentContent: '<p slot="t">1</p><div></div><p slot="t">2</p>'
-    })
-    expect(child.$el.innerHTML).toBe('<p>1</p><p>2</p>')
-  })
-
-  it('default content should only render parts not selected', () => {
-    mount({
-      childTemplate: `
-        <div>
-          <slot name="a"></slot>
-          <slot></slot>
-          <slot name="b"></slot>
-        </div>
-      `,
-      parentContent: '<div>foo</div><p slot="a">1</p><p slot="b">2</p>'
-    })
-    expect(child.$el.innerHTML).toBe('<p>1</p> <div>foo</div> <p>2</p>')
-  })
-
-  it('name should only match children', function () {
-    mount({
-      childTemplate: `
-        <div>
-          <slot name="a"><p>fallback a</p></slot>
-          <slot name="b"><p>fallback b</p></slot>
-          <slot name="c"><p>fallback c</p></slot>
-        </div>
-      `,
-      parentContent: `
-        '<p slot="b">select b</p>
-        '<span><p slot="b">nested b</p></span>
-        '<span><p slot="c">nested c</p></span>
-      `
-    })
-    expect(child.$el.children.length).toBe(3)
-    expect(child.$el.children[0].textContent).toBe('fallback a')
-    expect(child.$el.children[1].textContent).toBe('select b')
-    expect(child.$el.children[2].textContent).toBe('fallback c')
-  })
-
-  it('should accept expressions in slot attribute and slot names', () => {
-    mount({
-      childTemplate: `<div><slot :name="'a'"></slot></div>`,
-      parentContent: `<p>one</p><p :slot="'a'">two</p>`
-    })
-    expect(child.$el.innerHTML).toBe('<p>two</p>')
-  })
-
-  it('slot inside v-if', done => {
-    const vm = new Vue({
-      data: {
-        a: 1,
-        b: 2,
-        show: true
-      },
-      template: '<test :show="show"><p slot="b">{{b}}</p><p>{{a}}</p></test>',
-      components: {
-        test: {
-          props: ['show'],
-          template: '<div v-if="show"><slot></slot><slot name="b"></slot></div>'
-        }
-      }
-    }).$mount()
-    expect(vm.$el.textContent).toBe('12')
-    vm.a = 2
-    waitForUpdate(() => {
-      expect(vm.$el.textContent).toBe('22')
-      vm.show = false
-    }).then(() => {
-      expect(vm.$el.textContent).toBe('')
-      vm.show = true
-      vm.a = 3
-    }).then(() => {
-      expect(vm.$el.textContent).toBe('32')
-    }).then(done)
-  })
-
-  it('slot inside v-for', () => {
-    mount({
-      childTemplate: '<div><slot v-for="i in 3" :name="i"></slot></div>',
-      parentContent: '<p v-for="i in 3" :slot="i">{{ i - 1 }}</p>'
-    })
-    expect(child.$el.innerHTML).toBe('<p>0</p><p>1</p><p>2</p>')
-  })
-
-  it('nested slots', done => {
-    const vm = new Vue({
-      template: '<test><test2><p>{{ msg }}</p></test2></test>',
-      data: {
-        msg: 'foo'
-      },
-      components: {
-        test: {
-          template: '<div><slot></slot></div>'
-        },
-        test2: {
-          template: '<div><slot></slot></div>'
-        }
-      }
-    }).$mount()
-    expect(vm.$el.innerHTML).toBe('<div><p>foo</p></div>')
-    vm.msg = 'bar'
-    waitForUpdate(() => {
-      expect(vm.$el.innerHTML).toBe('<div><p>bar</p></div>')
-    }).then(done)
-  })
-
-  it('v-if on inserted content', done => {
-    const vm = new Vue({
-      template: '<test><p v-if="ok">{{ msg }}</p></test>',
-      data: {
-        ok: true,
-        msg: 'hi'
-      },
-      components: {
-        test: {
-          template: '<div><slot>fallback</slot></div>'
-        }
-      }
-    }).$mount()
-    expect(vm.$el.innerHTML).toBe('<p>hi</p>')
-    vm.ok = false
-    waitForUpdate(() => {
-      expect(vm.$el.innerHTML).toBe('fallback')
-      vm.ok = true
-      vm.msg = 'bye'
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<p>bye</p>')
-    }).then(done)
-  })
-
-  it('template slot', function () {
-    const vm = new Vue({
-      template: '<test><template slot="test">hello</template></test>',
-      components: {
-        test: {
-          template: '<div><slot name="test"></slot> world</div>'
-        }
-      }
-    }).$mount()
-    expect(vm.$el.innerHTML).toBe('hello world')
-  })
-
-  it('combined with v-for', () => {
-    const vm = new Vue({
-      template: '<div><test v-for="i in 3" :key="i">{{ i }}</test></div>',
-      components: {
-        test: {
-          template: '<div><slot></slot></div>'
-        }
-      }
-    }).$mount()
-    expect(vm.$el.innerHTML).toBe('<div>1</div><div>2</div><div>3</div>')
-  })
-
-  it('inside template v-if', () => {
-    mount({
-      childTemplate: `
-        <div>
-          <template v-if="true"><slot></slot></template>
-        </div>
-      `,
-      parentContent: 'foo'
-    })
-    expect(child.$el.innerHTML).toBe('foo')
-  })
-
-  it('default slot should use fallback content if has only whitespace', () => {
-    mount({
-      childTemplate: `
-        <div>
-          <slot name="first"><p>first slot</p></slot>
-          <slot><p>this is the default slot</p></slot>
-          <slot name="second"><p>second named slot</p></slot>
-        </div>
-      `,
-      parentContent: `<div slot="first">1</div> <div slot="second">2</div> <div slot="second">2+</div>`
-    })
-    expect(child.$el.innerHTML).toBe(
-      '<div>1</div> <p>this is the default slot</p> <div>2</div><div>2+</div>'
-    )
-  })
-
-  it('programmatic access to $slots', () => {
-    const vm = new Vue({
-      template: '<test><p slot="a">A</p><div>C</div><p slot="b">B</p></test>',
-      components: {
-        test: {
-          render () {
-            expect(this.$slots.a.length).toBe(1)
-            expect(this.$slots.a[0].tag).toBe('p')
-            expect(this.$slots.a[0].children.length).toBe(1)
-            expect(this.$slots.a[0].children[0].text).toBe('A')
-
-            expect(this.$slots.b.length).toBe(1)
-            expect(this.$slots.b[0].tag).toBe('p')
-            expect(this.$slots.b[0].children.length).toBe(1)
-            expect(this.$slots.b[0].children[0].text).toBe('B')
-
-            expect(this.$slots.default.length).toBe(1)
-            expect(this.$slots.default[0].tag).toBe('div')
-            expect(this.$slots.default[0].children.length).toBe(1)
-            expect(this.$slots.default[0].children[0].text).toBe('C')
-
-            return this.$slots.default[0]
-          }
-        }
-      }
-    }).$mount()
-    expect(vm.$el.tagName).toBe('DIV')
-    expect(vm.$el.textContent).toBe('C')
-  })
-
-  it('warn if user directly returns array', () => {
-    new Vue({
-      template: '<test><div slot="foo"></div><div slot="foo"></div></test>',
-      components: {
-        test: {
-          render () {
-            return this.$slots.foo
-          }
-        }
-      }
-    }).$mount()
-    expect('Render function should return a single root node').toHaveBeenWarned()
-  })
-
-  // #3254
-  it('should not keep slot name when passed further down', () => {
-    const vm = new Vue({
-      template: '<test><span slot="foo">foo</span></test>',
-      components: {
-        test: {
-          template: '<child><slot name="foo"></slot></child>',
-          components: {
-            child: {
-              template: `
-                <div>
-                  <div class="default"><slot></slot></div>
-                  <div class="named"><slot name="foo"></slot></div>
-                </div>
-              `
-            }
-          }
-        }
-      }
-    }).$mount()
-    expect(vm.$el.querySelector('.default').textContent).toBe('foo')
-    expect(vm.$el.querySelector('.named').textContent).toBe('')
-  })
-
-  it('should not keep slot name when passed further down (nested)', () => {
-    const vm = new Vue({
-      template: '<wrap><test><span slot="foo">foo</span></test></wrap>',
-      components: {
-        wrap: {
-          template: '<div><slot></slot></div>'
-        },
-        test: {
-          template: '<child><slot name="foo"></slot></child>',
-          components: {
-            child: {
-              template: `
-                <div>
-                  <div class="default"><slot></slot></div>
-                  <div class="named"><slot name="foo"></slot></div>
-                </div>
-              `
-            }
-          }
-        }
-      }
-    }).$mount()
-    expect(vm.$el.querySelector('.default').textContent).toBe('foo')
-    expect(vm.$el.querySelector('.named').textContent).toBe('')
-  })
-
-  it('should not keep slot name when passed further down (functional)', () => {
-    const child = {
-      template: `
-        <div>
-          <div class="default"><slot></slot></div>
-          <div class="named"><slot name="foo"></slot></div>
-        </div>
-      `
-    }
-
-    const vm = new Vue({
-      template: '<test><span slot="foo">foo</span></test>',
-      components: {
-        test: {
-          functional: true,
-          render (h, ctx) {
-            const slots = ctx.slots()
-            return h(child, slots.foo)
-          }
-        }
-      }
-    }).$mount()
-    expect(vm.$el.querySelector('.default').textContent).toBe('foo')
-    expect(vm.$el.querySelector('.named').textContent).toBe('')
-  })
-
-  // #3400
-  it('named slots should be consistent across re-renders', done => {
-    const vm = new Vue({
-      template: `
-        <comp>
-          <div slot="foo">foo</div>
-        </comp>
-      `,
-      components: {
-        comp: {
-          data () {
-            return { a: 1 }
-          },
-          template: `<div><slot name="foo"></slot>{{ a }}</div>`
-        }
-      }
-    }).$mount()
-    expect(vm.$el.textContent).toBe('foo1')
-    vm.$children[0].a = 2
-    waitForUpdate(() => {
-      expect(vm.$el.textContent).toBe('foo2')
-    }).then(done)
-  })
-
-  // #3437
-  it('should correctly re-create components in slot', done => {
-    const calls = []
-    const vm = new Vue({
-      template: `
-        <comp ref="child">
-          <div slot="foo">
-            <child></child>
-          </div>
-        </comp>
-      `,
-      components: {
-        comp: {
-          data () {
-            return { ok: true }
-          },
-          template: `<div><slot name="foo" v-if="ok"></slot></div>`
-        },
-        child: {
-          template: '<div>child</div>',
-          created () {
-            calls.push(1)
-          },
-          destroyed () {
-            calls.push(2)
-          }
-        }
-      }
-    }).$mount()
-
-    expect(calls).toEqual([1])
-    vm.$refs.child.ok = false
-    waitForUpdate(() => {
-      expect(calls).toEqual([1, 2])
-      vm.$refs.child.ok = true
-    }).then(() => {
-      expect(calls).toEqual([1, 2, 1])
-      vm.$refs.child.ok = false
-    }).then(() => {
-      expect(calls).toEqual([1, 2, 1, 2])
-    }).then(done)
-  })
-
-  it('should support duplicate slots', done => {
-    const vm = new Vue({
-      template: `
-        <foo ref="foo">
-          <div slot="a">{{ n }}</div>
-        </foo>
-      `,
-      data: {
-        n: 1
-      },
-      components: {
-        foo: {
-          data() {
-            return { ok: true }
-          },
-          template: `
-            <div>
-              <slot name="a" />
-              <slot v-if="ok" name="a" />
-              <pre><slot name="a" /></pre>
-            </div>
-          `
-        }
-      }
-    }).$mount()
-    expect(vm.$el.innerHTML).toBe(`<div>1</div> <div>1</div> <pre><div>1</div></pre>`)
-    vm.n++
-    waitForUpdate(() => {
-      expect(vm.$el.innerHTML).toBe(`<div>2</div> <div>2</div> <pre><div>2</div></pre>`)
-      vm.n++
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe(`<div>3</div> <div>3</div> <pre><div>3</div></pre>`)
-      vm.$refs.foo.ok = false
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe(`<div>3</div> <!----> <pre><div>3</div></pre>`)
-      vm.n++
-      vm.$refs.foo.ok = true
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe(`<div>4</div> <div>4</div> <pre><div>4</div></pre>`)
-    }).then(done)
-  })
-
-  // #3518
-  it('events should not break when slot is toggled by v-if', done => {
-    const spy = jasmine.createSpy()
-    const vm = new Vue({
-      template: `<test><div class="click" @click="test">hi</div></test>`,
-      methods: {
-        test: spy
-      },
-      components: {
-        test: {
-          data: () => ({
-            toggle: true
-          }),
-          template: `<div v-if="toggle"><slot></slot></div>`
-        }
-      }
-    }).$mount()
-
-    document.body.appendChild(vm.$el)
-    expect(vm.$el.textContent).toBe('hi')
-    vm.$children[0].toggle = false
-    waitForUpdate(() => {
-      vm.$children[0].toggle = true
-    }).then(() => {
-      triggerEvent(vm.$el.querySelector('.click'), 'click')
-      expect(spy).toHaveBeenCalled()
-    }).then(() => {
-      document.body.removeChild(vm.$el)
-    }).then(done)
-  })
-
-  it('renders static tree with text', () => {
-    const vm = new Vue({
-      template: `<div><test><template><div></div>Hello<div></div></template></test></div>`,
-      components: {
-        test: {
-          template: '<div><slot></slot></div>'
-        }
-      }
-    })
-    vm.$mount()
-    expect('Error when rendering root').not.toHaveBeenWarned()
-  })
-
-  // #3872
-  it('functional component as slot', () => {
-    const vm = new Vue({
-      template: `
-        <parent>
-          <child>one</child>
-          <child slot="a">two</child>
-        </parent>
-      `,
-      components: {
-        parent: {
-          template: `<div><slot name="a"></slot><slot></slot></div>`
-        },
-        child: {
-          functional: true,
-          render (h, { slots }) {
-            return h('div', slots().default)
-          }
-        }
-      }
-    }).$mount()
-    expect(vm.$el.innerHTML.trim()).toBe('<div>two</div><div>one</div>')
-  })
-
-  // #4209
-  it('slot of multiple text nodes should not be infinitely merged', done => {
-    const wrap = {
-      template: `<inner ref="inner">foo<slot></slot></inner>`,
-      components: {
-        inner: {
-          data: () => ({ a: 1 }),
-          template: `<div>{{a}}<slot></slot></div>`
-        }
-      }
-    }
-    const vm = new Vue({
-      template: `<wrap ref="wrap">bar</wrap>`,
-      components: { wrap }
-    }).$mount()
-
-    expect(vm.$el.textContent).toBe('1foobar')
-    vm.$refs.wrap.$refs.inner.a++
-    waitForUpdate(() => {
-      expect(vm.$el.textContent).toBe('2foobar')
-    }).then(done)
-  })
-
-  // #4315
-  it('functional component passing slot content to stateful child component', done => {
-    const ComponentWithSlots = {
-      render (h) {
-        return h('div', this.$slots.slot1)
-      }
-    }
-
-    const FunctionalComp = {
-      functional: true,
-      render (h) {
-        return h(ComponentWithSlots, [h('span', { slot: 'slot1' }, 'foo')])
-      }
-    }
-
-    const vm = new Vue({
-      data: { n: 1 },
-      render (h) {
-        return h('div', [this.n, h(FunctionalComp)])
-      }
-    }).$mount()
-
-    expect(vm.$el.textContent).toBe('1foo')
-    vm.n++
-    waitForUpdate(() => {
-      // should not lose named slot
-      expect(vm.$el.textContent).toBe('2foo')
-    }).then(done)
-  })
-
-  it('the elements of slot should be updated correctly', done => {
-    const vm = new Vue({
-      data: { n: 1 },
-      template: '<div><test><span v-for="i in n" :key="i">{{ i }}</span><input value="a"/></test></div>',
-      components: {
-        test: {
-          template: '<div><slot></slot></div>'
-        }
-      }
-    }).$mount()
-    expect(vm.$el.innerHTML).toBe('<div><span>1</span><input value="a"></div>')
-    const input = vm.$el.querySelector('input')
-    input.value = 'b'
-    vm.n++
-    waitForUpdate(() => {
-      expect(vm.$el.innerHTML).toBe('<div><span>1</span><span>2</span><input value="a"></div>')
-      expect(vm.$el.querySelector('input')).toBe(input)
-      expect(vm.$el.querySelector('input').value).toBe('b')
-    }).then(done)
-  })
-
-  // GitHub issue #5888
-  it('should resolve correctly slot with keep-alive', () => {
-    const vm = new Vue({
-      template: `
-      <div>
-        <container>
-          <keep-alive slot="foo">
-            <child></child>
-          </keep-alive>
-        </container>
-      </div>
-      `,
-      components: {
-        container: {
-          template:
-            '<div><slot>default</slot><slot name="foo">named</slot></div>'
-        },
-        child: {
-          template: '<span>foo</span>'
-        }
-      }
-    }).$mount()
-    expect(vm.$el.innerHTML).toBe('<div>default<span>foo</span></div>')
-  })
-
-  // #6372, #6915
-  it('should handle nested components in slots properly', done => {
-    const TestComponent = {
-      template: `
-        <component :is="toggleEl ? 'b' : 'i'">
-          <slot />
-        </component>
-      `,
-      data () {
-        return {
-          toggleEl: true
-        }
-      }
-    }
-
-    const vm = new Vue({
-      template: `
-        <div>
-          <test-component ref="test">
-            <div>
-              <foo/>
-            </div>
-            <bar>
-              <foo/>
-            </bar>
-          </test-component>
-        </div>
-      `,
-      components: {
-        TestComponent,
-        foo: {
-          template: `<div>foo</div>`
-        },
-        bar: {
-          template: `<div>bar<slot/></div>`
-        }
-      }
-    }).$mount()
-
-    expect(vm.$el.innerHTML).toBe(`<b><div><div>foo</div></div> <div>bar<div>foo</div></div></b>`)
-
-    vm.$refs.test.toggleEl = false
-    waitForUpdate(() => {
-      expect(vm.$el.innerHTML).toBe(`<i><div><div>foo</div></div> <div>bar<div>foo</div></div></i>`)
-    }).then(done)
-  })
-
-  it('should preserve slot attribute if not absorbed by a Vue component', () => {
-    const vm = new Vue({
-      template: `
-        <div>
-          <div slot="foo"></div>
-        </div>
-      `
-    }).$mount()
-    expect(vm.$el.children[0].getAttribute('slot')).toBe('foo')
-  })
-
-  it('passing a slot down as named slot', () => {
-    const Bar = {
-      template: `<div class="bar"><slot name="foo"/></div>`
-    }
-
-    const Foo = {
-      components: { Bar },
-      template: `<div class="foo"><bar><slot slot="foo"/></bar></div>`
-    }
-
-    const vm = new Vue({
-      components: { Foo },
-      template: `<div><foo>hello</foo></div>`
-    }).$mount()
-
-    expect(vm.$el.innerHTML).toBe('<div class="foo"><div class="bar">hello</div></div>')
-  })
-
-  it('fallback content for named template slot', () => {
-    const Bar = {
-      template: `<div class="bar"><slot name="foo">fallback</slot></div>`
-    }
-
-    const Foo = {
-      components: { Bar },
-      template: `<div class="foo"><bar><template slot="foo"/><slot/></template></bar></div>`
-    }
-
-    const vm = new Vue({
-      components: { Foo },
-      template: `<div><foo></foo></div>`
-    }).$mount()
-
-    expect(vm.$el.innerHTML).toBe('<div class="foo"><div class="bar">fallback</div></div>')
-  })
-
-  // #7106
-  it('should not lose functional slot across renders', done => {
-    const One = {
-      data: () => ({
-        foo: true
-      }),
-      render (h) {
-        this.foo
-        return h('div', this.$slots.slot)
-      }
-    }
-
-    const Two = {
-      render (h) {
-        return h('span', this.$slots.slot)
-      }
-    }
-
-    const Three = {
-      functional: true,
-      render: (h, { children }) => h('span', children)
-    }
-
-    const vm = new Vue({
-      template: `
-        <div>
-          <one ref="one">
-            <two slot="slot">
-              <three slot="slot">hello</three>
-            </two>
-          </one>
-        </div>
-      `,
-      components: { One, Two, Three }
-    }).$mount()
-
-    expect(vm.$el.textContent).toBe('hello')
-    // trigger re-render of <one>
-    vm.$refs.one.foo = false
-    waitForUpdate(() => {
-      // should still be there
-      expect(vm.$el.textContent).toBe('hello')
-    }).then(done)
-  })
-
-  it('should allow passing named slots as raw children down multiple layers of functional component', () => {
-    const CompB = {
-      functional: true,
-      render (h, { slots }) {
-        return slots().foo
-      }
-    }
-
-    const CompA = {
-      functional: true,
-      render (h, { children }) {
-        return h(CompB, children)
-      }
-    }
-
-    const vm = new Vue({
-      components: {
-        CompA
-      },
-      template: `
-        <div>
-          <comp-a>
-            <span slot="foo">foo</span>
-          </comp-a>
-        </div>
-      `
-    }).$mount()
-
-    expect(vm.$el.textContent).toBe('foo')
-  })
-
-  // #7817
-  it('should not match wrong named slot in functional component on re-render', done => {
-    const Functional = {
-      functional: true,
-      render: (h, ctx) => ctx.slots().default
-    }
-
-    const Stateful = {
-      data () {
-        return { ok: true }
-      },
-      render (h) {
-        this.ok // register dep
-        return h('div', [
-          h(Functional, this.$slots.named)
-        ])
-      }
-    }
-
-    const vm = new Vue({
-      template: `<stateful ref="stateful"><div slot="named">foo</div></stateful>`,
-      components: { Stateful }
-    }).$mount()
-
-    expect(vm.$el.textContent).toBe('foo')
-    vm.$refs.stateful.ok = false
-    waitForUpdate(() => {
-      expect(vm.$el.textContent).toBe('foo')
-    }).then(done)
-  })
-
-  // #7975
-  it('should update named slot correctly when its position in the tree changed', done => {
-    const ChildComponent = {
-      template: '<b>{{ message }}</b>',
-      props: ['message']
-    }
-     let parentVm
-    const ParentComponent = {
-      template: `
-        <div>
-          <span v-if="alter">
-            <span><slot name="foo" /></span>
-          </span>
-          <span v-else>
-            <slot name="foo" />
-          </span>
-        </div>
-      `,
-      data () {
-        return {
-          alter: true
-        }
-      },
-      mounted () {
-        parentVm = this
-      }
-    }
-     const vm = new Vue({
-      template: `
-        <parent-component>
-          <span slot="foo">
-            <child-component :message="message" />
-          </span>
-        </parent-component>
-      `,
-      components: {
-        ChildComponent,
-        ParentComponent
-      },
-      data () {
-        return {
-          message: 1
-        }
-      }
-    }).$mount()
-     expect(vm.$el.firstChild.innerHTML).toBe('<span><span><b>1</b></span></span>')
-    parentVm.alter = false
-    waitForUpdate(() => {
-      vm.message = 2
-    }).then(() => {
-      expect(vm.$el.firstChild.innerHTML).toBe('<span><b>2</b></span>')
-    }).then(done)
-  })
-})
diff --git a/1.Vue/test/unit/features/component/component.spec.js b/1.Vue/test/unit/features/component/component.spec.js
deleted file mode 100644
index 34c037a..0000000
--- a/1.Vue/test/unit/features/component/component.spec.js
+++ /dev/null
@@ -1,429 +0,0 @@
-import Vue from 'vue'
-
-describe('Component', () => {
-  it('static', () => {
-    const vm = new Vue({
-      template: '<test></test>',
-      components: {
-        test: {
-          data () {
-            return { a: 123 }
-          },
-          template: '<span>{{a}}</span>'
-        }
-      }
-    }).$mount()
-    expect(vm.$el.tagName).toBe('SPAN')
-    expect(vm.$el.innerHTML).toBe('123')
-  })
-
-  it('using component in restricted elements', () => {
-    const vm = new Vue({
-      template: '<div><table><tbody><test></test></tbody></table></div>',
-      components: {
-        test: {
-          data () {
-            return { a: 123 }
-          },
-          template: '<tr><td>{{a}}</td></tr>'
-        }
-      }
-    }).$mount()
-    expect(vm.$el.innerHTML).toBe('<table><tbody><tr><td>123</td></tr></tbody></table>')
-  })
-
-  it('"is" attribute', () => {
-    const vm = new Vue({
-      template: '<div><table><tbody><tr is="test"></tr></tbody></table></div>',
-      components: {
-        test: {
-          data () {
-            return { a: 123 }
-          },
-          template: '<tr><td>{{a}}</td></tr>'
-        }
-      }
-    }).$mount()
-    expect(vm.$el.innerHTML).toBe('<table><tbody><tr><td>123</td></tr></tbody></table>')
-  })
-
-  it('inline-template', () => {
-    const vm = new Vue({
-      template: '<div><test inline-template><span>{{a}}</span></test></div>',
-      data: {
-        a: 'parent'
-      },
-      components: {
-        test: {
-          data () {
-            return { a: 'child' }
-          }
-        }
-      }
-    }).$mount()
-    expect(vm.$el.innerHTML).toBe('<span>child</span>')
-  })
-
-  it('fragment instance warning', () => {
-    new Vue({
-      template: '<test></test>',
-      components: {
-        test: {
-          data () {
-            return { a: 123, b: 234 }
-          },
-          template: '<p>{{a}}</p><p>{{b}}</p>'
-        }
-      }
-    }).$mount()
-    expect('Component template should contain exactly one root element').toHaveBeenWarned()
-  })
-
-  it('dynamic', done => {
-    const vm = new Vue({
-      template: '<component :is="view" :view="view"></component>',
-      data: {
-        view: 'view-a'
-      },
-      components: {
-        'view-a': {
-          template: '<div>foo {{view}}</div>',
-          data () {
-            return { view: 'a' }
-          }
-        },
-        'view-b': {
-          template: '<div>bar {{view}}</div>',
-          data () {
-            return { view: 'b' }
-          }
-        }
-      }
-    }).$mount()
-    expect(vm.$el.outerHTML).toBe('<div view="view-a">foo a</div>')
-    vm.view = 'view-b'
-    waitForUpdate(() => {
-      expect(vm.$el.outerHTML).toBe('<div view="view-b">bar b</div>')
-      vm.view = ''
-    })
-      .then(() => {
-        expect(vm.$el.nodeType).toBe(8)
-        expect(vm.$el.data).toBe('')
-      }).then(done)
-  })
-
-  it('dynamic with props', done => {
-    const vm = new Vue({
-      template: '<component :is="view" :view="view"></component>',
-      data: {
-        view: 'view-a'
-      },
-      components: {
-        'view-a': {
-          template: '<div>foo {{view}}</div>',
-          props: ['view']
-        },
-        'view-b': {
-          template: '<div>bar {{view}}</div>',
-          props: ['view']
-        }
-      }
-    }).$mount()
-    expect(vm.$el.outerHTML).toBe('<div>foo view-a</div>')
-    vm.view = 'view-b'
-    waitForUpdate(() => {
-      expect(vm.$el.outerHTML).toBe('<div>bar view-b</div>')
-      vm.view = ''
-    }).then(() => {
-      expect(vm.$el.nodeType).toBe(8)
-      expect(vm.$el.data).toBe('')
-    }).then(done)
-  })
-
-  it(':is using raw component constructor', () => {
-    const vm = new Vue({
-      template:
-        '<div>' +
-          '<component :is="$options.components.test"></component>' +
-          '<component :is="$options.components.async"></component>' +
-        '</div>',
-      components: {
-        test: {
-          template: '<span>foo</span>'
-        },
-        async: function (resolve) {
-          resolve({
-            template: '<span>bar</span>'
-          })
-        }
-      }
-    }).$mount()
-    expect(vm.$el.innerHTML).toBe('<span>foo</span><span>bar</span>')
-  })
-
-  it('dynamic combined with v-for', done => {
-    const vm = new Vue({
-      template:
-        '<div>' +
-          '<component v-for="(c, i) in comps" :key="i" :is="c.type"></component>' +
-        '</div>',
-      data: {
-        comps: [{ type: 'one' }, { type: 'two' }]
-      },
-      components: {
-        one: {
-          template: '<span>one</span>'
-        },
-        two: {
-          template: '<span>two</span>'
-        }
-      }
-    }).$mount()
-    expect(vm.$el.innerHTML).toBe('<span>one</span><span>two</span>')
-    vm.comps[1].type = 'one'
-    waitForUpdate(() => {
-      expect(vm.$el.innerHTML).toBe('<span>one</span><span>one</span>')
-    }).then(done)
-  })
-
-  it('dynamic elements with domProps', done => {
-    const vm = new Vue({
-      template: '<component :is="view" :value.prop="val"></component>',
-      data: {
-        view: 'input',
-        val: 'hello'
-      }
-    }).$mount()
-    expect(vm.$el.tagName).toBe('INPUT')
-    expect(vm.$el.value).toBe('hello')
-    vm.view = 'textarea'
-    vm.val += ' world'
-    waitForUpdate(() => {
-      expect(vm.$el.tagName).toBe('TEXTAREA')
-      expect(vm.$el.value).toBe('hello world')
-      vm.view = ''
-    }).then(done)
-  })
-
-  it('should compile parent template directives & content in parent scope', done => {
-    const vm = new Vue({
-      data: {
-        ok: false,
-        message: 'hello'
-      },
-      template: '<test v-show="ok">{{message}}</test>',
-      components: {
-        test: {
-          template: '<div><slot></slot> {{message}}</div>',
-          data () {
-            return {
-              message: 'world'
-            }
-          }
-        }
-      }
-    }).$mount()
-    expect(vm.$el.style.display).toBe('none')
-    expect(vm.$el.textContent).toBe('hello world')
-    vm.ok = true
-    vm.message = 'bye'
-    waitForUpdate(() => {
-      expect(vm.$el.style.display).toBe('')
-      expect(vm.$el.textContent).toBe('bye world')
-    }).then(done)
-  })
-
-  it('parent content + v-if', done => {
-    const vm = new Vue({
-      data: {
-        ok: false,
-        message: 'hello'
-      },
-      template: '<test v-if="ok">{{message}}</test>',
-      components: {
-        test: {
-          template: '<div><slot></slot> {{message}}</div>',
-          data () {
-            return {
-              message: 'world'
-            }
-          }
-        }
-      }
-    }).$mount()
-    expect(vm.$el.textContent).toBe('')
-    expect(vm.$children.length).toBe(0)
-    vm.ok = true
-    waitForUpdate(() => {
-      expect(vm.$children.length).toBe(1)
-      expect(vm.$el.textContent).toBe('hello world')
-    }).then(done)
-  })
-
-  it('props', () => {
-    const vm = new Vue({
-      data: {
-        list: [{ a: 1 }, { a: 2 }]
-      },
-      template: '<test :collection="list"></test>',
-      components: {
-        test: {
-          template: '<ul><li v-for="item in collection">{{item.a}}</li></ul>',
-          props: ['collection']
-        }
-      }
-    }).$mount()
-    expect(vm.$el.outerHTML).toBe('<ul><li>1</li><li>2</li></ul>')
-  })
-
-  it('should warn when using camelCased props in in-DOM template', () => {
-    new Vue({
-      data: {
-        list: [{ a: 1 }, { a: 2 }]
-      },
-      template: '<test :somecollection="list"></test>', // <-- simulate lowercased template
-      components: {
-        test: {
-          template: '<ul><li v-for="item in someCollection">{{item.a}}</li></ul>',
-          props: ['someCollection']
-        }
-      }
-    }).$mount()
-    expect(
-      'You should probably use "some-collection" instead of "someCollection".'
-    ).toHaveBeenTipped()
-  })
-
-  it('should warn when using camelCased events in in-DOM template', () => {
-    new Vue({
-      template: '<test @foobar="a++"></test>', // <-- simulate lowercased template
-      components: {
-        test: {
-          template: '<div></div>',
-          created () {
-            this.$emit('fooBar')
-          }
-        }
-      }
-    }).$mount()
-    expect(
-      'You should probably use "foo-bar" instead of "fooBar".'
-    ).toHaveBeenTipped()
-  })
-
-  it('not found component should not throw', () => {
-    expect(function () {
-      new Vue({
-        template: '<div is="non-existent"></div>'
-      })
-    }).not.toThrow()
-  })
-
-  it('properly update replaced higher-order component root node', done => {
-    const vm = new Vue({
-      data: {
-        color: 'red'
-      },
-      template: '<test id="foo" :class="color"></test>',
-      components: {
-        test: {
-          data () {
-            return { tag: 'div' }
-          },
-          render (h) {
-            return h(this.tag, { class: 'test' }, 'hi')
-          }
-        }
-      }
-    }).$mount()
-
-    expect(vm.$el.tagName).toBe('DIV')
-    expect(vm.$el.id).toBe('foo')
-    expect(vm.$el.className).toBe('test red')
-
-    vm.color = 'green'
-    waitForUpdate(() => {
-      expect(vm.$el.tagName).toBe('DIV')
-      expect(vm.$el.id).toBe('foo')
-      expect(vm.$el.className).toBe('test green')
-      vm.$children[0].tag = 'p'
-    }).then(() => {
-      expect(vm.$el.tagName).toBe('P')
-      expect(vm.$el.id).toBe('foo')
-      expect(vm.$el.className).toBe('test green')
-      vm.color = 'red'
-    }).then(() => {
-      expect(vm.$el.tagName).toBe('P')
-      expect(vm.$el.id).toBe('foo')
-      expect(vm.$el.className).toBe('test red')
-    }).then(done)
-  })
-
-  it('catch component render error and preserve previous vnode', done => {
-    const spy = jasmine.createSpy()
-    Vue.config.errorHandler = spy
-    const vm = new Vue({
-      data: {
-        a: {
-          b: 123
-        }
-      },
-      render (h) {
-        return h('div', [this.a.b])
-      }
-    }).$mount()
-    expect(vm.$el.textContent).toBe('123')
-    expect(spy).not.toHaveBeenCalled()
-    vm.a = null
-    waitForUpdate(() => {
-      expect(spy).toHaveBeenCalled()
-      expect(vm.$el.textContent).toBe('123') // should preserve rendered DOM
-      vm.a = { b: 234 }
-    }).then(() => {
-      expect(vm.$el.textContent).toBe('234') // should be able to recover
-      Vue.config.errorHandler = null
-    }).then(done)
-  })
-
-  it('relocates node without error', done => {
-    const el = document.createElement('div')
-    document.body.appendChild(el)
-    const target = document.createElement('div')
-    document.body.appendChild(target)
-
-    const Test = {
-      render (h) {
-        return h('div', { class: 'test' }, this.$slots.default)
-      },
-      mounted () {
-        target.appendChild(this.$el)
-      },
-      beforeDestroy () {
-        const parent = this.$el.parentNode
-        if (parent) {
-          parent.removeChild(this.$el)
-        }
-      }
-    }
-    const vm = new Vue({
-      data () {
-        return {
-          view: true
-        }
-      },
-      template: `<div><test v-if="view">Test</test></div>`,
-      components: {
-        test: Test
-      }
-    }).$mount(el)
-
-    expect(el.outerHTML).toBe('<div></div>')
-    expect(target.outerHTML).toBe('<div><div class="test">Test</div></div>')
-    vm.view = false
-    waitForUpdate(() => {
-      expect(el.outerHTML).toBe('<div></div>')
-      expect(target.outerHTML).toBe('<div></div>')
-      vm.$destroy()
-    }).then(done)
-  })
-})
diff --git a/1.Vue/test/unit/features/debug.spec.js b/1.Vue/test/unit/features/debug.spec.js
deleted file mode 100644
index ff49532..0000000
--- a/1.Vue/test/unit/features/debug.spec.js
+++ /dev/null
@@ -1,117 +0,0 @@
-import Vue from 'vue'
-import { formatComponentName, warn } from 'core/util/debug'
-
-describe('Debug utilities', () => {
-  it('properly format component names', () => {
-    const vm = new Vue()
-    expect(formatComponentName(vm)).toBe('<Root>')
-
-    vm.$root = null
-    vm.$options.name = 'hello-there'
-    expect(formatComponentName(vm)).toBe('<HelloThere>')
-
-    vm.$options.name = null
-    vm.$options._componentTag = 'foo-bar-1'
-    expect(formatComponentName(vm)).toBe('<FooBar1>')
-
-    vm.$options._componentTag = null
-    vm.$options.__file = '/foo/bar/baz/SomeThing.vue'
-    expect(formatComponentName(vm)).toBe(`<SomeThing> at ${vm.$options.__file}`)
-    expect(formatComponentName(vm, false)).toBe('<SomeThing>')
-
-    vm.$options.__file = 'C:\\foo\\bar\\baz\\windows_file.vue'
-    expect(formatComponentName(vm)).toBe(`<WindowsFile> at ${vm.$options.__file}`)
-    expect(formatComponentName(vm, false)).toBe('<WindowsFile>')
-  })
-
-  it('generate correct component hierarchy trace', () => {
-    const one = {
-      name: 'one',
-      render: h => h(two)
-    }
-    const two = {
-      name: 'two',
-      render: h => h(three)
-    }
-    const three = {
-      name: 'three'
-    }
-    new Vue({
-      render: h => h(one)
-    }).$mount()
-
-    expect(
-      `Failed to mount component: template or render function not defined.
-
-found in
-
----> <Three>
-       <Two>
-         <One>
-           <Root>`
-    ).toHaveBeenWarned()
-  })
-
-  it('generate correct component hierarchy trace (recursive)', () => {
-    let i = 0
-    const one = {
-      name: 'one',
-      render: h => i++ < 5 ? h(one) : h(two)
-    }
-    const two = {
-      name: 'two',
-      render: h => h(three)
-    }
-    const three = {
-      name: 'three'
-    }
-    new Vue({
-      render: h => h(one)
-    }).$mount()
-
-    expect(
-      `Failed to mount component: template or render function not defined.
-
-found in
-
----> <Three>
-       <Two>
-         <One>... (5 recursive calls)
-           <Root>`
-    ).toHaveBeenWarned()
-  })
-
-  describe('warn', () => {
-    const msg = 'message'
-    const vm = new Vue()
-
-    it('calls warnHandler if warnHandler is set', () => {
-      Vue.config.warnHandler = jasmine.createSpy()
-
-      warn(msg, vm)
-
-      expect(Vue.config.warnHandler).toHaveBeenCalledWith(msg, vm, jasmine.any(String))
-
-      Vue.config.warnHandler = null
-    })
-
-    it('calls console.error if silent is false', () => {
-      Vue.config.silent = false
-
-      warn(msg, vm)
-
-      expect(msg).toHaveBeenWarned()
-      expect(console.error).toHaveBeenCalled()
-    })
-
-    it('does not call console.error if silent is true', () => {
-      Vue.config.silent = true
-
-      warn(msg, vm)
-
-      expect(console.error).not.toHaveBeenCalled()
-
-      Vue.config.silent = false
-    })
-  })
-})
diff --git a/1.Vue/test/unit/features/directives/bind.spec.js b/1.Vue/test/unit/features/directives/bind.spec.js
deleted file mode 100644
index 7e4827d..0000000
--- a/1.Vue/test/unit/features/directives/bind.spec.js
+++ /dev/null
@@ -1,603 +0,0 @@
-import Vue from 'vue'
-
-describe('Directive v-bind', () => {
-  it('normal attr', done => {
-    const vm = new Vue({
-      template: '<div><span :test="foo">hello</span></div>',
-      data: { foo: 'ok' }
-    }).$mount()
-    expect(vm.$el.firstChild.getAttribute('test')).toBe('ok')
-    vm.foo = 'again'
-    waitForUpdate(() => {
-      expect(vm.$el.firstChild.getAttribute('test')).toBe('again')
-      vm.foo = null
-    }).then(() => {
-      expect(vm.$el.firstChild.hasAttribute('test')).toBe(false)
-      vm.foo = false
-    }).then(() => {
-      expect(vm.$el.firstChild.hasAttribute('test')).toBe(false)
-      vm.foo = true
-    }).then(() => {
-      expect(vm.$el.firstChild.getAttribute('test')).toBe('true')
-      vm.foo = 0
-    }).then(() => {
-      expect(vm.$el.firstChild.getAttribute('test')).toBe('0')
-    }).then(done)
-  })
-
-  it('should set property for input value', done => {
-    const vm = new Vue({
-      template: `
-        <div>
-          <input type="text" :value="foo">
-          <input type="checkbox" :checked="bar">
-        </div>
-      `,
-      data: {
-        foo: 'ok',
-        bar: false
-      }
-    }).$mount()
-    expect(vm.$el.firstChild.value).toBe('ok')
-    expect(vm.$el.lastChild.checked).toBe(false)
-    vm.bar = true
-    waitForUpdate(() => {
-      expect(vm.$el.lastChild.checked).toBe(true)
-    }).then(done)
-  })
-
-  it('xlink', done => {
-    const vm = new Vue({
-      template: '<svg><a :xlink:special="foo"></a></svg>',
-      data: {
-        foo: 'ok'
-      }
-    }).$mount()
-    const xlinkNS = 'http://www.w3.org/1999/xlink'
-    expect(vm.$el.firstChild.getAttributeNS(xlinkNS, 'special')).toBe('ok')
-    vm.foo = 'again'
-    waitForUpdate(() => {
-      expect(vm.$el.firstChild.getAttributeNS(xlinkNS, 'special')).toBe('again')
-      vm.foo = null
-    }).then(() => {
-      expect(vm.$el.firstChild.hasAttributeNS(xlinkNS, 'special')).toBe(false)
-      vm.foo = true
-    }).then(() => {
-      expect(vm.$el.firstChild.getAttributeNS(xlinkNS, 'special')).toBe('true')
-    }).then(done)
-  })
-
-  it('enumerated attr', done => {
-    const vm = new Vue({
-      template: '<div><span :contenteditable="foo">hello</span></div>',
-      data: { foo: true }
-    }).$mount()
-    expect(vm.$el.firstChild.getAttribute('contenteditable')).toBe('true')
-    vm.foo = 'plaintext-only' // allow special values
-    waitForUpdate(() => {
-      expect(vm.$el.firstChild.getAttribute('contenteditable')).toBe('plaintext-only')
-      vm.foo = null
-    }).then(() => {
-      expect(vm.$el.firstChild.getAttribute('contenteditable')).toBe('false')
-      vm.foo = ''
-    }).then(() => {
-      expect(vm.$el.firstChild.getAttribute('contenteditable')).toBe('true')
-      vm.foo = false
-    }).then(() => {
-      expect(vm.$el.firstChild.getAttribute('contenteditable')).toBe('false')
-      vm.foo = 'false'
-    }).then(() => {
-      expect(vm.$el.firstChild.getAttribute('contenteditable')).toBe('false')
-    }).then(done)
-  })
-
-  it('boolean attr', done => {
-    const vm = new Vue({
-      template: '<div><span :disabled="foo">hello</span></div>',
-      data: { foo: true }
-    }).$mount()
-    expect(vm.$el.firstChild.getAttribute('disabled')).toBe('disabled')
-    vm.foo = 'again'
-    waitForUpdate(() => {
-      expect(vm.$el.firstChild.getAttribute('disabled')).toBe('disabled')
-      vm.foo = null
-    }).then(() => {
-      expect(vm.$el.firstChild.hasAttribute('disabled')).toBe(false)
-      vm.foo = ''
-    }).then(() => {
-      expect(vm.$el.firstChild.hasAttribute('disabled')).toBe(true)
-    }).then(done)
-  })
-
-  it('.prop modifier', () => {
-    const vm = new Vue({
-      template: '<div><span v-bind:text-content.prop="foo"></span><span :inner-html.prop="bar"></span></div>',
-      data: {
-        foo: 'hello',
-        bar: '<span>qux</span>'
-      }
-    }).$mount()
-    expect(vm.$el.children[0].textContent).toBe('hello')
-    expect(vm.$el.children[1].innerHTML).toBe('<span>qux</span>')
-  })
-
-  it('.prop modifier with normal attribute binding', () => {
-    const vm = new Vue({
-      template: '<input :some.prop="some" :id="id">',
-      data: {
-        some: 'hello',
-        id: false
-      }
-    }).$mount()
-    expect(vm.$el.some).toBe('hello')
-    expect(vm.$el.getAttribute('id')).toBe(null)
-  })
-
-  if (process.env.VBIND_PROP_SHORTHAND) {
-    it('.prop modifier shorthand', () => {
-      const vm = new Vue({
-        template: '<div><span .text-content="foo"></span><span .inner-html="bar"></span></div>',
-        data: {
-          foo: 'hello',
-          bar: '<span>qux</span>'
-        }
-      }).$mount()
-      expect(vm.$el.children[0].textContent).toBe('hello')
-      expect(vm.$el.children[1].innerHTML).toBe('<span>qux</span>')
-    })
-  }
-
-  it('.camel modifier', () => {
-    const vm = new Vue({
-      template: '<svg :view-box.camel="viewBox"></svg>',
-      data: {
-        viewBox: '0 0 1 1'
-      }
-    }).$mount()
-    expect(vm.$el.getAttribute('viewBox')).toBe('0 0 1 1')
-  })
-
-  it('.sync modifier', done => {
-    const vm = new Vue({
-      template: `<test :foo-bar.sync="bar"/>`,
-      data: {
-        bar: 1
-      },
-      components: {
-        test: {
-          props: ['fooBar'],
-          template: `<div @click="$emit('update:fooBar', 2)">{{ fooBar }}</div>`
-        }
-      }
-    }).$mount()
-
-    document.body.appendChild(vm.$el)
-    expect(vm.$el.textContent).toBe('1')
-    triggerEvent(vm.$el, 'click')
-    waitForUpdate(() => {
-      expect(vm.$el.textContent).toBe('2')
-      document.body.removeChild(vm.$el)
-    }).then(done)
-  })
-
-  it('.sync modifier with kebab case event', done => {
-    const vm = new Vue({
-      template: `<test ref="test" :foo-bar.sync="bar"/>`,
-      data: {
-        bar: 1
-      },
-      components: {
-        test: {
-          props: ['fooBar'],
-          template: `<div>{{ fooBar }}</div>`,
-          methods: {
-            update () {
-              this.$emit('update:foo-bar', 2)
-            }
-          }
-        }
-      }
-    }).$mount()
-
-    expect(vm.$el.textContent).toBe('1')
-    vm.$refs.test.update()
-    waitForUpdate(() => {
-      expect(vm.$el.textContent).toBe('2')
-    }).then(done)
-  })
-
-  it('bind object', done => {
-    const vm = new Vue({
-      template: '<input v-bind="test">',
-      data: {
-        test: {
-          id: 'test',
-          class: 'ok',
-          value: 'hello'
-        }
-      }
-    }).$mount()
-    expect(vm.$el.getAttribute('id')).toBe('test')
-    expect(vm.$el.getAttribute('class')).toBe('ok')
-    expect(vm.$el.value).toBe('hello')
-    vm.test.id = 'hi'
-    vm.test.value = 'bye'
-    waitForUpdate(() => {
-      expect(vm.$el.getAttribute('id')).toBe('hi')
-      expect(vm.$el.getAttribute('class')).toBe('ok')
-      expect(vm.$el.value).toBe('bye')
-    }).then(done)
-  })
-
-  it('bind object with explicit overrides', () => {
-    const vm = new Vue({
-      template: `<test v-bind="test" data-foo="foo" dataBar="bar"/>`,
-      components: {
-        test: {
-          template: '<div>{{ dataFoo }} {{ dataBar }}</div>',
-          props: ['dataFoo', 'dataBar']
-        }
-      },
-      data: {
-        test: {
-          dataFoo: 'hi',
-          dataBar: 'bye'
-        }
-      }
-    }).$mount()
-    expect(vm.$el.textContent).toBe('foo bar')
-  })
-
-  it('.sync modifier with bind object', done => {
-    const vm = new Vue({
-      template: `<test v-bind.sync="test"/>`,
-      data: {
-        test: {
-          fooBar: 1
-        }
-      },
-      components: {
-        test: {
-          props: ['fooBar'],
-          template: `<div @click="handleUpdate">{{ fooBar }}</div>`,
-          methods: {
-            handleUpdate () {
-              this.$emit('update:fooBar', 2)
-            }
-          }
-        }
-      }
-    }).$mount()
-    document.body.appendChild(vm.$el)
-    expect(vm.$el.textContent).toBe('1')
-    triggerEvent(vm.$el, 'click')
-    waitForUpdate(() => {
-      expect(vm.$el.textContent).toBe('2')
-      vm.test.fooBar = 3
-    }).then(() => {
-      expect(vm.$el.textContent).toBe('3')
-      document.body.removeChild(vm.$el)
-    }).then(done)
-  })
-
-  it('bind object with overwrite', done => {
-    const vm = new Vue({
-      template: '<input v-bind="test" id="foo" :class="test.value">',
-      data: {
-        test: {
-          id: 'test',
-          class: 'ok',
-          value: 'hello'
-        }
-      }
-    }).$mount()
-    expect(vm.$el.getAttribute('id')).toBe('foo')
-    expect(vm.$el.getAttribute('class')).toBe('hello')
-    expect(vm.$el.value).toBe('hello')
-    vm.test.id = 'hi'
-    vm.test.value = 'bye'
-    waitForUpdate(() => {
-      expect(vm.$el.getAttribute('id')).toBe('foo')
-      expect(vm.$el.getAttribute('class')).toBe('bye')
-      expect(vm.$el.value).toBe('bye')
-    }).then(done)
-  })
-
-  it('bind object with class/style', done => {
-    const vm = new Vue({
-      template: '<input class="a" style="color:red" v-bind="test">',
-      data: {
-        test: {
-          id: 'test',
-          class: ['b', 'c'],
-          style: { fontSize: '12px' }
-        }
-      }
-    }).$mount()
-    expect(vm.$el.id).toBe('test')
-    expect(vm.$el.className).toBe('a b c')
-    expect(vm.$el.style.color).toBe('red')
-    expect(vm.$el.style.fontSize).toBe('12px')
-    vm.test.id = 'hi'
-    vm.test.class = ['d']
-    vm.test.style = { fontSize: '14px' }
-    waitForUpdate(() => {
-      expect(vm.$el.id).toBe('hi')
-      expect(vm.$el.className).toBe('a d')
-      expect(vm.$el.style.color).toBe('red')
-      expect(vm.$el.style.fontSize).toBe('14px')
-    }).then(done)
-  })
-
-  it('bind object as prop', done => {
-    const vm = new Vue({
-      template: '<input v-bind.prop="test">',
-      data: {
-        test: {
-          id: 'test',
-          className: 'ok',
-          value: 'hello'
-        }
-      }
-    }).$mount()
-    expect(vm.$el.id).toBe('test')
-    expect(vm.$el.className).toBe('ok')
-    expect(vm.$el.value).toBe('hello')
-    vm.test.id = 'hi'
-    vm.test.className = 'okay'
-    vm.test.value = 'bye'
-    waitForUpdate(() => {
-      expect(vm.$el.id).toBe('hi')
-      expect(vm.$el.className).toBe('okay')
-      expect(vm.$el.value).toBe('bye')
-    }).then(done)
-  })
-
-  it('bind array', done => {
-    const vm = new Vue({
-      template: '<input v-bind="test">',
-      data: {
-        test: [
-          { id: 'test', class: 'ok' },
-          { value: 'hello' }
-        ]
-      }
-    }).$mount()
-    expect(vm.$el.getAttribute('id')).toBe('test')
-    expect(vm.$el.getAttribute('class')).toBe('ok')
-    expect(vm.$el.value).toBe('hello')
-    vm.test[0].id = 'hi'
-    vm.test[1].value = 'bye'
-    waitForUpdate(() => {
-      expect(vm.$el.getAttribute('id')).toBe('hi')
-      expect(vm.$el.getAttribute('class')).toBe('ok')
-      expect(vm.$el.value).toBe('bye')
-    }).then(done)
-  })
-
-  it('warn expect object', () => {
-    new Vue({
-      template: '<input v-bind="test">',
-      data: {
-        test: 1
-      }
-    }).$mount()
-    expect('v-bind without argument expects an Object or Array value').toHaveBeenWarned()
-  })
-
-  it('set value for option element', () => {
-    const vm = new Vue({
-      template: '<select><option :value="val">val</option></select>',
-      data: {
-        val: 'val'
-      }
-    }).$mount()
-    // check value attribute
-    expect(vm.$el.options[0].getAttribute('value')).toBe('val')
-  })
-
-  // a vdom patch edge case where the user has several un-keyed elements of the
-  // same tag next to each other, and toggling them.
-  it('properly update for toggling un-keyed children', done => {
-    const vm = new Vue({
-      template: `
-        <div>
-          <div v-if="ok" id="a" data-test="1"></div>
-          <div v-if="!ok" id="b"></div>
-        </div>
-      `,
-      data: {
-        ok: true
-      }
-    }).$mount()
-    expect(vm.$el.children[0].id).toBe('a')
-    expect(vm.$el.children[0].getAttribute('data-test')).toBe('1')
-    vm.ok = false
-    waitForUpdate(() => {
-      expect(vm.$el.children[0].id).toBe('b')
-      expect(vm.$el.children[0].getAttribute('data-test')).toBe(null)
-    }).then(done)
-  })
-
-  describe('bind object with special attribute', () => {
-    function makeInstance (options) {
-      return new Vue({
-        template: `<div>${options.parentTemp}</div>`,
-        data: {
-          attrs: {
-            [options.attr]: options.value
-          }
-        },
-        components: {
-          comp: {
-            template: options.childTemp
-          }
-        }
-      }).$mount()
-    }
-
-    it('key', () => {
-      const vm = makeInstance({
-        attr: 'key',
-        value: 'test',
-        parentTemp: '<div v-bind="attrs"></div>'
-      })
-      expect(vm._vnode.children[0].key).toBe('test')
-    })
-
-    it('ref', () => {
-      const vm = makeInstance({
-        attr: 'ref',
-        value: 'test',
-        parentTemp: '<div v-bind="attrs"></div>'
-      })
-      expect(vm.$refs.test).toBe(vm.$el.firstChild)
-    })
-
-    it('slot', () => {
-      const vm = makeInstance({
-        attr: 'slot',
-        value: 'test',
-        parentTemp: '<comp><span v-bind="attrs">123</span></comp>',
-        childTemp: '<div>slot:<slot name="test"></slot></div>'
-      })
-      expect(vm.$el.innerHTML).toBe('<div>slot:<span>123</span></div>')
-    })
-
-    it('is', () => {
-      const vm = makeInstance({
-        attr: 'is',
-        value: 'comp',
-        parentTemp: '<component v-bind="attrs"></component>',
-        childTemp: '<div>comp</div>'
-      })
-      expect(vm.$el.innerHTML).toBe('<div>comp</div>')
-    })
-  })
-
-  describe('dynamic arguments', () => {
-    it('basic', done => {
-      const vm = new Vue({
-        template: `<div v-bind:[key]="value"></div>`,
-        data: {
-          key: 'id',
-          value: 'hello'
-        }
-      }).$mount()
-      expect(vm.$el.id).toBe('hello')
-      vm.key = 'class'
-      waitForUpdate(() => {
-        expect(vm.$el.id).toBe('')
-        expect(vm.$el.className).toBe('hello')
-        // explicit null value
-        vm.key = null
-      }).then(() => {
-        expect(vm.$el.className).toBe('')
-        expect(vm.$el.id).toBe('')
-        vm.key = undefined
-      }).then(() => {
-        expect(`Invalid value for dynamic directive argument`).toHaveBeenWarned()
-      }).then(done)
-    })
-
-    it('shorthand', done => {
-      const vm = new Vue({
-        template: `<div :[key]="value"></div>`,
-        data: {
-          key: 'id',
-          value: 'hello'
-        }
-      }).$mount()
-      expect(vm.$el.id).toBe('hello')
-      vm.key = 'class'
-      waitForUpdate(() => {
-        expect(vm.$el.className).toBe('hello')
-      }).then(done)
-    })
-
-    it('with .prop modifier', done => {
-      const vm = new Vue({
-        template: `<div :[key].prop="value"></div>`,
-        data: {
-          key: 'id',
-          value: 'hello'
-        }
-      }).$mount()
-      expect(vm.$el.id).toBe('hello')
-      vm.key = 'textContent'
-      waitForUpdate(() => {
-        expect(vm.$el.textContent).toBe('hello')
-      }).then(done)
-    })
-
-    if (process.env.VBIND_PROP_SHORTHAND) {
-      it('.prop shorthand', done => {
-        const vm = new Vue({
-          template: `<div .[key]="value"></div>`,
-          data: {
-            key: 'id',
-            value: 'hello'
-          }
-        }).$mount()
-        expect(vm.$el.id).toBe('hello')
-        vm.key = 'textContent'
-        waitForUpdate(() => {
-          expect(vm.$el.textContent).toBe('hello')
-        }).then(done)
-      })
-    }
-
-    it('handle class and style', () => {
-      const vm = new Vue({
-        template: `<div :[key]="value" :[key2]="value2"></div>`,
-        data: {
-          key: 'class',
-          value: ['hello', 'world'],
-          key2: 'style',
-          value2: {
-            color: 'red'
-          }
-        }
-      }).$mount()
-      expect(vm.$el.className).toBe('hello world')
-      expect(vm.$el.style.color).toBe('red')
-    })
-
-    it('handle shouldUseProp', done => {
-      const vm = new Vue({
-        template: `<input :[key]="value">`,
-        data: {
-          key: 'value',
-          value: 'foo'
-        }
-      }).$mount()
-      expect(vm.$el.value).toBe('foo')
-      vm.value = 'bar'
-      waitForUpdate(() => {
-        expect(vm.$el.value).toBe('bar')
-      }).then(done)
-    })
-
-    it('with .sync modifier', done => {
-      const vm = new Vue({
-        template: `<foo ref="child" :[key].sync="value"/>`,
-        data: {
-          key: 'foo',
-          value: 'bar'
-        },
-        components: {
-          foo: {
-            props: ['foo'],
-            template: `<div>{{ foo }}</div>`
-          }
-        }
-      }).$mount()
-      expect(vm.$el.textContent).toBe('bar')
-      vm.$refs.child.$emit('update:foo', 'baz')
-      waitForUpdate(() => {
-        expect(vm.value).toBe('baz')
-        expect(vm.$el.textContent).toBe('baz')
-      }).then(done)
-    })
-  })
-})
diff --git a/1.Vue/test/unit/features/directives/class.spec.js b/1.Vue/test/unit/features/directives/class.spec.js
deleted file mode 100644
index 0ee3380..0000000
--- a/1.Vue/test/unit/features/directives/class.spec.js
+++ /dev/null
@@ -1,175 +0,0 @@
-import Vue from 'vue'
-
-function assertClass (assertions, done) {
-  const vm = new Vue({
-    template: '<div class="foo" :class="value"></div>',
-    data: { value: '' }
-  }).$mount()
-  const chain = waitForUpdate()
-  assertions.forEach(([value, expected], i) => {
-    chain.then(() => {
-      if (typeof value === 'function') {
-        value(vm.value)
-      } else {
-        vm.value = value
-      }
-    }).then(() => {
-      expect(vm.$el.className).toBe(expected)
-      if (i >= assertions.length - 1) {
-        done()
-      }
-    })
-  })
-  chain.then(done)
-}
-
-describe('Directive v-bind:class', () => {
-  it('plain string', done => {
-    assertClass([
-      ['bar', 'foo bar'],
-      ['baz qux', 'foo baz qux'],
-      ['qux', 'foo qux'],
-      [undefined, 'foo']
-    ], done)
-  })
-
-  it('object value', done => {
-    assertClass([
-      [{ bar: true, baz: false }, 'foo bar'],
-      [{ baz: true }, 'foo baz'],
-      [null, 'foo'],
-      [{ 'bar baz': true, qux: false }, 'foo bar baz'],
-      [{ qux: true }, 'foo qux']
-    ], done)
-  })
-
-  it('array value', done => {
-    assertClass([
-      [['bar', 'baz'], 'foo bar baz'],
-      [['qux', 'baz'], 'foo qux baz'],
-      [['w', 'x y z'], 'foo w x y z'],
-      [undefined, 'foo'],
-      [['bar'], 'foo bar'],
-      [val => val.push('baz'), 'foo bar baz']
-    ], done)
-  })
-
-  it('array of mixed values', done => {
-    assertClass([
-      [['x', { y: true, z: true }], 'foo x y z'],
-      [['x', { y: true, z: false }], 'foo x y'],
-      [['f', { z: true }], 'foo f z'],
-      [['l', 'f', { n: true, z: true }], 'foo l f n z'],
-      [['x', {}], 'foo x'],
-      [undefined, 'foo']
-    ], done)
-  })
-
-  it('class merge between parent and child', done => {
-    const vm = new Vue({
-      template: '<child class="a" :class="value"></child>',
-      data: { value: 'b' },
-      components: {
-        child: {
-          template: '<div class="c" :class="value"></div>',
-          data: () => ({ value: 'd' })
-        }
-      }
-    }).$mount()
-    const child = vm.$children[0]
-    expect(vm.$el.className).toBe('c a d b')
-    vm.value = 'e'
-    waitForUpdate(() => {
-      expect(vm.$el.className).toBe('c a d e')
-    }).then(() => {
-      child.value = 'f'
-    }).then(() => {
-      expect(vm.$el.className).toBe('c a f e')
-    }).then(() => {
-      vm.value = { foo: true }
-      child.value = ['bar', 'baz']
-    }).then(() => {
-      expect(vm.$el.className).toBe('c a bar baz foo')
-    }).then(done)
-  })
-
-  it('class merge between multiple nested components sharing same element', done => {
-    const vm = new Vue({
-      template: `
-        <component1 :class="componentClass1">
-          <component2 :class="componentClass2">
-            <component3 :class="componentClass3">
-              some text
-            </component3>
-          </component2>
-        </component1>
-      `,
-      data: {
-        componentClass1: 'componentClass1',
-        componentClass2: 'componentClass2',
-        componentClass3: 'componentClass3'
-      },
-      components: {
-        component1: {
-          render () {
-            return this.$slots.default[0]
-          }
-        },
-        component2: {
-          render () {
-            return this.$slots.default[0]
-          }
-        },
-        component3: {
-          template: '<div class="staticClass"><slot></slot></div>'
-        }
-      }
-    }).$mount()
-    expect(vm.$el.className).toBe('staticClass componentClass3 componentClass2 componentClass1')
-    vm.componentClass1 = 'c1'
-    waitForUpdate(() => {
-      expect(vm.$el.className).toBe('staticClass componentClass3 componentClass2 c1')
-      vm.componentClass2 = 'c2'
-    }).then(() => {
-      expect(vm.$el.className).toBe('staticClass componentClass3 c2 c1')
-      vm.componentClass3 = 'c3'
-    }).then(() => {
-      expect(vm.$el.className).toBe('staticClass c3 c2 c1')
-    }).then(done)
-  })
-
-  it('deep update', done => {
-    const vm = new Vue({
-      template: '<div :class="test"></div>',
-      data: {
-        test: { a: true, b: false }
-      }
-    }).$mount()
-    expect(vm.$el.className).toBe('a')
-    vm.test.b = true
-    waitForUpdate(() => {
-      expect(vm.$el.className).toBe('a b')
-    }).then(done)
-  })
-
-  // a vdom patch edge case where the user has several un-keyed elements of the
-  // same tag next to each other, and toggling them.
-  it('properly remove staticClass for toggling un-keyed children', done => {
-    const vm = new Vue({
-      template: `
-        <div>
-          <div v-if="ok" class="a"></div>
-          <div v-if="!ok"></div>
-        </div>
-      `,
-      data: {
-        ok: true
-      }
-    }).$mount()
-    expect(vm.$el.children[0].className).toBe('a')
-    vm.ok = false
-    waitForUpdate(() => {
-      expect(vm.$el.children[0].className).toBe('')
-    }).then(done)
-  })
-})
diff --git a/1.Vue/test/unit/features/directives/cloak.spec.js b/1.Vue/test/unit/features/directives/cloak.spec.js
deleted file mode 100644
index 618d21b..0000000
--- a/1.Vue/test/unit/features/directives/cloak.spec.js
+++ /dev/null
@@ -1,10 +0,0 @@
-import Vue from 'vue'
-
-describe('Directive v-cloak', () => {
-  it('should be removed after compile', () => {
-    const el = document.createElement('div')
-    el.setAttribute('v-cloak', '')
-    const vm = new Vue({ el })
-    expect(vm.$el.hasAttribute('v-cloak')).toBe(false)
-  })
-})
diff --git a/1.Vue/test/unit/features/directives/for.spec.js b/1.Vue/test/unit/features/directives/for.spec.js
deleted file mode 100644
index eb28b09..0000000
--- a/1.Vue/test/unit/features/directives/for.spec.js
+++ /dev/null
@@ -1,771 +0,0 @@
-import Vue from 'vue'
-import { hasSymbol } from 'core/util/env'
-
-describe('Directive v-for', () => {
-  it('should render array of primitive values', done => {
-    const vm = new Vue({
-      template: `
-        <div>
-          <span v-for="item in list">{{item}}</span>
-        </div>
-      `,
-      data: {
-        list: ['a', 'b', 'c']
-      }
-    }).$mount()
-    expect(vm.$el.innerHTML).toBe('<span>a</span><span>b</span><span>c</span>')
-    Vue.set(vm.list, 0, 'd')
-    waitForUpdate(() => {
-      expect(vm.$el.innerHTML).toBe('<span>d</span><span>b</span><span>c</span>')
-      vm.list.push('d')
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<span>d</span><span>b</span><span>c</span><span>d</span>')
-      vm.list.splice(1, 2)
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<span>d</span><span>d</span>')
-      vm.list = ['x', 'y']
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<span>x</span><span>y</span>')
-    }).then(done)
-  })
-
-  it('should render array of primitive values with index', done => {
-    const vm = new Vue({
-      template: `
-        <div>
-          <span v-for="(item, i) in list">{{i}}-{{item}}</span>
-        </div>
-      `,
-      data: {
-        list: ['a', 'b', 'c']
-      }
-    }).$mount()
-    expect(vm.$el.innerHTML).toBe('<span>0-a</span><span>1-b</span><span>2-c</span>')
-    Vue.set(vm.list, 0, 'd')
-    waitForUpdate(() => {
-      expect(vm.$el.innerHTML).toBe('<span>0-d</span><span>1-b</span><span>2-c</span>')
-      vm.list.push('d')
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<span>0-d</span><span>1-b</span><span>2-c</span><span>3-d</span>')
-      vm.list.splice(1, 2)
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<span>0-d</span><span>1-d</span>')
-      vm.list = ['x', 'y']
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<span>0-x</span><span>1-y</span>')
-    }).then(done)
-  })
-
-  it('should render array of object values', done => {
-    const vm = new Vue({
-      template: `
-        <div>
-          <span v-for="item in list">{{item.value}}</span>
-        </div>
-      `,
-      data: {
-        list: [
-          { value: 'a' },
-          { value: 'b' },
-          { value: 'c' }
-        ]
-      }
-    }).$mount()
-    expect(vm.$el.innerHTML).toBe('<span>a</span><span>b</span><span>c</span>')
-    Vue.set(vm.list, 0, { value: 'd' })
-    waitForUpdate(() => {
-      expect(vm.$el.innerHTML).toBe('<span>d</span><span>b</span><span>c</span>')
-      vm.list[0].value = 'e'
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<span>e</span><span>b</span><span>c</span>')
-      vm.list.push({})
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<span>e</span><span>b</span><span>c</span><span></span>')
-      vm.list.splice(1, 2)
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<span>e</span><span></span>')
-      vm.list = [{ value: 'x' }, { value: 'y' }]
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<span>x</span><span>y</span>')
-    }).then(done)
-  })
-
-  it('should render array of object values with index', done => {
-    const vm = new Vue({
-      template: `
-        <div>
-          <span v-for="(item, i) in list">{{i}}-{{item.value}}</span>
-        </div>
-      `,
-      data: {
-        list: [
-          { value: 'a' },
-          { value: 'b' },
-          { value: 'c' }
-        ]
-      }
-    }).$mount()
-    expect(vm.$el.innerHTML).toBe('<span>0-a</span><span>1-b</span><span>2-c</span>')
-    Vue.set(vm.list, 0, { value: 'd' })
-    waitForUpdate(() => {
-      expect(vm.$el.innerHTML).toBe('<span>0-d</span><span>1-b</span><span>2-c</span>')
-      vm.list[0].value = 'e'
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<span>0-e</span><span>1-b</span><span>2-c</span>')
-      vm.list.push({})
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<span>0-e</span><span>1-b</span><span>2-c</span><span>3-</span>')
-      vm.list.splice(1, 2)
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<span>0-e</span><span>1-</span>')
-      vm.list = [{ value: 'x' }, { value: 'y' }]
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<span>0-x</span><span>1-y</span>')
-    }).then(done)
-  })
-
-  if (hasSymbol) {
-    it('should render native iterables (Map)', () => {
-      const vm = new Vue({
-        template: `<div><span v-for="[key, val] in list">{{key}},{{val}}</span></div>`,
-        data: {
-          list: new Map([[1, 'foo'], [2, 'bar']])
-        }
-      }).$mount()
-      expect(vm.$el.innerHTML).toBe(`<span>1,foo</span><span>2,bar</span>`)
-    })
-
-    it('should render native iterables (Set)', () => {
-      const vm = new Vue({
-        template: `<div><span v-for="val in list">{{val}}</span></div>`,
-        data: {
-          list: new Set([1, 2, 3])
-        }
-      }).$mount()
-      expect(vm.$el.innerHTML).toBe(`<span>1</span><span>2</span><span>3</span>`)
-    })
-
-    it('should render iterable of primitive values', done => {
-      const iterable = {
-        models: ['a', 'b', 'c'],
-        index: 0,
-        [Symbol.iterator] () {
-          const iterator = {
-            index: 0,
-            models: this.models,
-            next () {
-              if (this.index < this.models.length) {
-                return { value: this.models[this.index++] }
-              } else {
-                return { done: true }
-              }
-            }
-          }
-          return iterator
-        }
-      }
-      const vm = new Vue({
-        template: `
-          <div>
-            <span v-for="item in list">{{item}}</span>
-          </div>
-        `,
-        data: {
-          list: iterable
-        }
-      }).$mount()
-      expect(vm.$el.innerHTML).toBe('<span>a</span><span>b</span><span>c</span>')
-      Vue.set(vm.list.models, 0, 'd')
-      waitForUpdate(() => {
-        expect(vm.$el.innerHTML).toBe('<span>d</span><span>b</span><span>c</span>')
-        vm.list.models.push('d')
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe('<span>d</span><span>b</span><span>c</span><span>d</span>')
-        vm.list.models.splice(1, 2)
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe('<span>d</span><span>d</span>')
-        vm.list.models = ['x', 'y']
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe('<span>x</span><span>y</span>')
-      }).then(done)
-    })
-
-    it('should render iterable of primitive values with index', done => {
-      const iterable = {
-        models: ['a', 'b', 'c'],
-        index: 0,
-        [Symbol.iterator] () {
-          const iterator = {
-            index: 0,
-            models: this.models,
-            next () {
-              if (this.index < this.models.length) {
-                return { value: this.models[this.index++] }
-              } else {
-                return { done: true }
-              }
-            }
-          }
-          return iterator
-        }
-      }
-
-      const vm = new Vue({
-        template: `
-          <div>
-            <span v-for="(item, i) in list">{{i}}-{{item}}</span>
-          </div>
-        `,
-        data: {
-          list: iterable
-        }
-      }).$mount()
-      expect(vm.$el.innerHTML).toBe('<span>0-a</span><span>1-b</span><span>2-c</span>')
-      Vue.set(vm.list.models, 0, 'd')
-      waitForUpdate(() => {
-        expect(vm.$el.innerHTML).toBe('<span>0-d</span><span>1-b</span><span>2-c</span>')
-        vm.list.models.push('d')
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe('<span>0-d</span><span>1-b</span><span>2-c</span><span>3-d</span>')
-        vm.list.models.splice(1, 2)
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe('<span>0-d</span><span>1-d</span>')
-        vm.list.models = ['x', 'y']
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe('<span>0-x</span><span>1-y</span>')
-      }).then(done)
-    })
-
-    it('should render iterable of object values', done => {
-      const iterable = {
-        models: [
-          { value: 'a' },
-          { value: 'b' },
-          { value: 'c' }
-        ],
-        index: 0,
-        [Symbol.iterator] () {
-          const iterator = {
-            index: 0,
-            models: this.models,
-            next () {
-              if (this.index < this.models.length) {
-                return { value: this.models[this.index++] }
-              } else {
-                return { done: true }
-              }
-            }
-          }
-          return iterator
-        }
-      }
-
-      const vm = new Vue({
-        template: `
-          <div>
-            <span v-for="item in list">{{item.value}}</span>
-          </div>
-        `,
-        data: {
-          list: iterable
-        }
-      }).$mount()
-      expect(vm.$el.innerHTML).toBe('<span>a</span><span>b</span><span>c</span>')
-      Vue.set(vm.list.models, 0, { value: 'd' })
-      waitForUpdate(() => {
-        expect(vm.$el.innerHTML).toBe('<span>d</span><span>b</span><span>c</span>')
-        vm.list.models[0].value = 'e'
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe('<span>e</span><span>b</span><span>c</span>')
-        vm.list.models.push({})
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe('<span>e</span><span>b</span><span>c</span><span></span>')
-        vm.list.models.splice(1, 2)
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe('<span>e</span><span></span>')
-        vm.list.models = [{ value: 'x' }, { value: 'y' }]
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe('<span>x</span><span>y</span>')
-      }).then(done)
-    })
-
-    it('should render iterable of object values with index', done => {
-      const iterable = {
-        models: [
-          { value: 'a' },
-          { value: 'b' },
-          { value: 'c' }
-        ],
-        index: 0,
-        [Symbol.iterator] () {
-          const iterator = {
-            index: 0,
-            models: this.models,
-            next () {
-              if (this.index < this.models.length) {
-                return { value: this.models[this.index++] }
-              } else {
-                return { done: true }
-              }
-            }
-          }
-          return iterator
-        }
-      }
-
-      const vm = new Vue({
-        template: `
-          <div>
-            <span v-for="(item, i) in list">{{i}}-{{item.value}}</span>
-          </div>
-        `,
-        data: {
-          list: iterable
-        }
-      }).$mount()
-      expect(vm.$el.innerHTML).toBe('<span>0-a</span><span>1-b</span><span>2-c</span>')
-      Vue.set(vm.list.models, 0, { value: 'd' })
-      waitForUpdate(() => {
-        expect(vm.$el.innerHTML).toBe('<span>0-d</span><span>1-b</span><span>2-c</span>')
-        vm.list.models[0].value = 'e'
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe('<span>0-e</span><span>1-b</span><span>2-c</span>')
-        vm.list.models.push({})
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe('<span>0-e</span><span>1-b</span><span>2-c</span><span>3-</span>')
-        vm.list.models.splice(1, 2)
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe('<span>0-e</span><span>1-</span>')
-        vm.list.models = [{ value: 'x' }, { value: 'y' }]
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe('<span>0-x</span><span>1-y</span>')
-      }).then(done)
-    })
-  }
-
-  it('should render an Object', done => {
-    const vm = new Vue({
-      template: `
-        <div>
-          <span v-for="val in obj">{{val}}</span>
-        </div>
-      `,
-      data: {
-        obj: { a: 0, b: 1, c: 2 }
-      }
-    }).$mount()
-    expect(vm.$el.innerHTML).toBe('<span>0</span><span>1</span><span>2</span>')
-    vm.obj.a = 3
-    waitForUpdate(() => {
-      expect(vm.$el.innerHTML).toBe('<span>3</span><span>1</span><span>2</span>')
-      Vue.set(vm.obj, 'd', 4)
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<span>3</span><span>1</span><span>2</span><span>4</span>')
-      Vue.delete(vm.obj, 'a')
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<span>1</span><span>2</span><span>4</span>')
-    }).then(done)
-  })
-
-  it('should render an Object with key', done => {
-    const vm = new Vue({
-      template: `
-        <div>
-          <span v-for="(val, key) in obj">{{val}}-{{key}}</span>
-        </div>
-      `,
-      data: {
-        obj: { a: 0, b: 1, c: 2 }
-      }
-    }).$mount()
-    expect(vm.$el.innerHTML).toBe('<span>0-a</span><span>1-b</span><span>2-c</span>')
-    vm.obj.a = 3
-    waitForUpdate(() => {
-      expect(vm.$el.innerHTML).toBe('<span>3-a</span><span>1-b</span><span>2-c</span>')
-      Vue.set(vm.obj, 'd', 4)
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<span>3-a</span><span>1-b</span><span>2-c</span><span>4-d</span>')
-      Vue.delete(vm.obj, 'a')
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<span>1-b</span><span>2-c</span><span>4-d</span>')
-    }).then(done)
-  })
-
-  it('should render an Object with key and index', done => {
-    const vm = new Vue({
-      template: `
-        <div>
-          <span v-for="(val, key, i) in obj">{{val}}-{{key}}-{{i}}</span>
-        </div>
-      `,
-      data: {
-        obj: { a: 0, b: 1, c: 2 }
-      }
-    }).$mount()
-    expect(vm.$el.innerHTML).toBe('<span>0-a-0</span><span>1-b-1</span><span>2-c-2</span>')
-    vm.obj.a = 3
-    waitForUpdate(() => {
-      expect(vm.$el.innerHTML).toBe('<span>3-a-0</span><span>1-b-1</span><span>2-c-2</span>')
-      Vue.set(vm.obj, 'd', 4)
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<span>3-a-0</span><span>1-b-1</span><span>2-c-2</span><span>4-d-3</span>')
-      Vue.delete(vm.obj, 'a')
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<span>1-b-0</span><span>2-c-1</span><span>4-d-2</span>')
-    }).then(done)
-  })
-
-  it('should render each key of data', done => {
-    const vm = new Vue({
-      template: `
-        <div>
-          <span v-for="(val, key) in $data">{{val}}-{{key}}</span>
-        </div>
-      `,
-      data: { a: 0, b: 1, c: 2 }
-    }).$mount()
-    expect(vm.$el.innerHTML).toBe('<span>0-a</span><span>1-b</span><span>2-c</span>')
-    vm.a = 3
-    waitForUpdate(() => {
-      expect(vm.$el.innerHTML).toBe('<span>3-a</span><span>1-b</span><span>2-c</span>')
-    }).then(done)
-  })
-
-  it('check priorities: v-if before v-for', function () {
-    const vm = new Vue({
-      data: {
-        items: [1, 2, 3]
-      },
-      template: '<div><div v-if="item < 3" v-for="item in items">{{item}}</div></div>'
-    }).$mount()
-    expect(vm.$el.textContent).toBe('12')
-  })
-
-  it('check priorities: v-if after v-for', function () {
-    const vm = new Vue({
-      data: {
-        items: [1, 2, 3]
-      },
-      template: '<div><div v-for="item in items" v-if="item < 3">{{item}}</div></div>'
-    }).$mount()
-    expect(vm.$el.textContent).toBe('12')
-  })
-
-  it('range v-for', () => {
-    const vm = new Vue({
-      template: '<div><div v-for="n in 3">{{n}}</div></div>'
-    }).$mount()
-    expect(vm.$el.textContent).toBe('123')
-  })
-
-  it('without key', done => {
-    const vm = new Vue({
-      data: {
-        items: [
-          { id: 1, msg: 'a' },
-          { id: 2, msg: 'b' },
-          { id: 3, msg: 'c' }
-        ]
-      },
-      template: '<div><div v-for="item in items">{{ item.msg }}</div></div>'
-    }).$mount()
-    expect(vm.$el.textContent).toBe('abc')
-    const first = vm.$el.children[0]
-    vm.items.reverse()
-    waitForUpdate(() => {
-      expect(vm.$el.textContent).toBe('cba')
-      // assert reusing DOM element in place
-      expect(vm.$el.children[0]).toBe(first)
-    }).then(done)
-  })
-
-  it('with key', done => {
-    const vm = new Vue({
-      data: {
-        items: [
-          { id: 1, msg: 'a' },
-          { id: 2, msg: 'b' },
-          { id: 3, msg: 'c' }
-        ]
-      },
-      template: '<div><div v-for="item in items" :key="item.id">{{ item.msg }}</div></div>'
-    }).$mount()
-    expect(vm.$el.textContent).toBe('abc')
-    const first = vm.$el.children[0]
-    vm.items.reverse()
-    waitForUpdate(() => {
-      expect(vm.$el.textContent).toBe('cba')
-      // assert moving DOM element
-      expect(vm.$el.children[0]).not.toBe(first)
-      expect(vm.$el.children[2]).toBe(first)
-    }).then(done)
-  })
-
-  it('nested loops', () => {
-    const vm = new Vue({
-      data: {
-        items: [
-          { items: [{ a: 1 }, { a: 2 }], a: 1 },
-          { items: [{ a: 3 }, { a: 4 }], a: 2 }
-        ]
-      },
-      template:
-        '<div>' +
-          '<div v-for="(item, i) in items">' +
-            '<p v-for="(subItem, j) in item.items">{{j}} {{subItem.a}} {{i}} {{item.a}}</p>' +
-          '</div>' +
-        '</div>'
-    }).$mount()
-    expect(vm.$el.innerHTML).toBe(
-      '<div><p>0 1 0 1</p><p>1 2 0 1</p></div>' +
-      '<div><p>0 3 1 2</p><p>1 4 1 2</p></div>'
-    )
-  })
-
-  it('template v-for', done => {
-    const vm = new Vue({
-      data: {
-        list: [
-          { a: 1 },
-          { a: 2 },
-          { a: 3 }
-        ]
-      },
-      template:
-        '<div>' +
-          '<template v-for="item in list">' +
-            '<p>{{item.a}}</p>' +
-            '<p>{{item.a + 1}}</p>' +
-          '</template>' +
-        '</div>'
-    }).$mount()
-    assertMarkup()
-    vm.list.reverse()
-    waitForUpdate(() => {
-      assertMarkup()
-      vm.list.splice(1, 1)
-    }).then(() => {
-      assertMarkup()
-      vm.list.splice(1, 0, { a: 2 })
-    }).then(done)
-
-    function assertMarkup () {
-      const markup = vm.list.map(function (item) {
-        return '<p>' + item.a + '</p><p>' + (item.a + 1) + '</p>'
-      }).join('')
-      expect(vm.$el.innerHTML).toBe(markup)
-    }
-  })
-
-  it('component v-for', done => {
-    const vm = new Vue({
-      data: {
-        list: [
-          { a: 1 },
-          { a: 2 },
-          { a: 3 }
-        ]
-      },
-      template:
-        '<div>' +
-          '<test v-for="item in list" :msg="item.a" :key="item.a">' +
-            '<span>{{item.a}}</span>' +
-          '</test>' +
-        '</div>',
-      components: {
-        test: {
-          props: ['msg'],
-          template: '<p>{{msg}}<slot></slot></p>'
-        }
-      }
-    }).$mount()
-    assertMarkup()
-    vm.list.reverse()
-    waitForUpdate(() => {
-      assertMarkup()
-      vm.list.splice(1, 1)
-    }).then(() => {
-      assertMarkup()
-      vm.list.splice(1, 0, { a: 2 })
-    }).then(done)
-
-    function assertMarkup () {
-      const markup = vm.list.map(function (item) {
-        return `<p>${item.a}<span>${item.a}</span></p>`
-      }).join('')
-      expect(vm.$el.innerHTML).toBe(markup)
-    }
-  })
-
-  it('dynamic component v-for', done => {
-    const vm = new Vue({
-      data: {
-        list: [
-          { type: 'one' },
-          { type: 'two' }
-        ]
-      },
-      template:
-        '<div>' +
-          '<component v-for="item in list" :key="item.type" :is="item.type"></component>' +
-        '</div>',
-      components: {
-        one: {
-          template: '<p>One!</p>'
-        },
-        two: {
-          template: '<div>Two!</div>'
-        }
-      }
-    }).$mount()
-    expect(vm.$el.innerHTML).toContain('<p>One!</p><div>Two!</div>')
-    vm.list.reverse()
-    waitForUpdate(() => {
-      expect(vm.$el.innerHTML).toContain('<div>Two!</div><p>One!</p>')
-    }).then(done)
-  })
-
-  it('should warn component v-for without keys', () => {
-    const warn = console.warn
-    console.warn = jasmine.createSpy()
-    new Vue({
-      template: `<div><test v-for="i in 3"></test></div>`,
-      components: {
-        test: {
-          render () {}
-        }
-      }
-    }).$mount()
-    expect(console.warn.calls.argsFor(0)[0]).toContain(
-      `<test v-for="i in 3">: component lists rendered with v-for should have explicit keys`
-    )
-    console.warn = warn
-  })
-
-  it('multi nested array reactivity', done => {
-    const vm = new Vue({
-      data: {
-        list: [[['foo']]]
-      },
-      template: `
-        <div>
-          <div v-for="i in list">
-            <div v-for="j in i">
-              <div v-for="k in j">
-                {{ k }}
-              </div>
-            </div>
-          </div>
-        </div>
-      `
-    }).$mount()
-    expect(vm.$el.textContent).toMatch(/\s+foo\s+/)
-    vm.list[0][0].push('bar')
-    waitForUpdate(() => {
-      expect(vm.$el.textContent).toMatch(/\s+foo\s+bar\s+/)
-    }).then(done)
-  })
-
-  it('should work with strings', done => {
-    const vm = new Vue({
-      data: {
-        text: 'foo'
-      },
-      template: `
-        <div>
-          <span v-for="letter in text">{{ letter }}.</span>
-        </div>
-      `
-    }).$mount()
-    expect(vm.$el.textContent).toMatch('f.o.o.')
-    vm.text += 'bar'
-    waitForUpdate(() => {
-      expect(vm.$el.textContent).toMatch('f.o.o.b.a.r.')
-    }).then(done)
-  })
-
-  // #7792
-  it('should work with multiline expressions', () => {
-    const vm = new Vue({
-      data: {
-        a: [1],
-        b: [2]
-      },
-      template: `
-        <div>
-          <span v-for="n in (
-            a.concat(
-              b
-            )
-          )">{{ n }}</span>
-        </div>
-      `
-    }).$mount()
-    expect(vm.$el.textContent).toBe('12')
-  })
-
-  // #9181
-  it('components with v-for and empty list', done => {
-    const vm = new Vue({
-      template:
-        '<div attr>' +
-          '<foo v-for="item in list" :key="item">{{ item }}</foo>' +
-        '</div>',
-      data: {
-        list: undefined
-      },
-      components: {
-        foo: {
-          template: '<div><slot></slot></div>'
-        },
-      }
-    }).$mount()
-    expect(vm.$el.innerHTML).toBe('')
-    vm.list = [1, 2, 3]
-    waitForUpdate(() => {
-      expect(vm.$el.innerHTML).toBe('<div>1</div><div>2</div><div>3</div>')
-    }).then(done)
-  })
-
-  it('elements with v-for and empty list', done => {
-    const vm = new Vue({
-      template:
-        '<div attr>' +
-          '<div v-for="item in list">{{ item }}</div>' +
-        '</div>',
-      data: {
-        list: undefined
-      }
-    }).$mount()
-    expect(vm.$el.innerHTML).toBe('')
-    vm.list = [1, 2, 3]
-    waitForUpdate(() => {
-      expect(vm.$el.innerHTML).toBe('<div>1</div><div>2</div><div>3</div>')
-    }).then(done)
-  })
-
-  const supportsDestructuring = (() => {
-    try {
-      new Function('var { foo } = bar')
-      return true
-    } catch (e) {}
-  })()
-
-  if (supportsDestructuring) {
-    it('should support destructuring syntax in alias position (object)', () => {
-      const vm = new Vue({
-        data: { list: [{ foo: 'hi', bar: 'ho' }] },
-        template: '<div><div v-for="({ foo, bar }, i) in list">{{ foo }} {{ bar }} {{ i }}</div></div>'
-      }).$mount()
-      expect(vm.$el.textContent).toBe('hi ho 0')
-    })
-
-    it('should support destructuring syntax in alias position (array)', () => {
-      const vm = new Vue({
-        data: { list: [[1, 2], [3, 4]] },
-        template: '<div><div v-for="([ foo, bar ], i) in list">{{ foo }} {{ bar }} {{ i }}</div></div>'
-      }).$mount()
-      expect(vm.$el.textContent).toBe('1 2 03 4 1')
-    })
-  }
-})
diff --git a/1.Vue/test/unit/features/directives/html.spec.js b/1.Vue/test/unit/features/directives/html.spec.js
deleted file mode 100644
index 5e67c81..0000000
--- a/1.Vue/test/unit/features/directives/html.spec.js
+++ /dev/null
@@ -1,73 +0,0 @@
-import Vue from 'vue'
-
-describe('Directive v-html', () => {
-  it('should render html', () => {
-    const vm = new Vue({
-      template: '<div v-html="a"></div>',
-      data: { a: 'hello' }
-    }).$mount()
-    expect(vm.$el.innerHTML).toBe('hello')
-  })
-
-  it('should encode html entities', () => {
-    const vm = new Vue({
-      template: '<div v-html="a"></div>',
-      data: { a: '<span>&lt;</span>' }
-    }).$mount()
-    expect(vm.$el.innerHTML).toBe('<span>&lt;</span>')
-  })
-
-  it('should work inline', () => {
-    const vm = new Vue({
-      template: `<div v-html="'<span>&lt;</span>'"></div>`
-    }).$mount()
-    expect(vm.$el.innerHTML).toBe('<span>&lt;</span>')
-  })
-
-  it('should work inline in DOM', () => {
-    const el = document.createElement('div')
-    el.innerHTML = `<div v-html="'<span>&lt;</span>'"></div>`
-    const vm = new Vue({ el })
-    expect(vm.$el.children[0].innerHTML).toBe('<span>&lt;</span>')
-  })
-
-  it('should support all value types', done => {
-    const vm = new Vue({
-      template: '<div v-html="a"></div>',
-      data: { a: false }
-    }).$mount()
-    waitForUpdate(() => {
-      expect(vm.$el.innerHTML).toBe('false')
-      vm.a = []
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('[]')
-      vm.a = {}
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('{}')
-      vm.a = { toString () { return 'foo' } }
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('foo')
-      vm.a = { toJSON () { return { foo: 'bar' } } }
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('{\n  "foo": "bar"\n}')
-      vm.a = 123
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('123')
-      vm.a = 0
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('0')
-      vm.a = ' '
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe(' ')
-      vm.a = '    '
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('    ')
-      vm.a = null
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('')
-      vm.a = undefined
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('')
-    }).then(done)
-  })
-})
diff --git a/1.Vue/test/unit/features/directives/if.spec.js b/1.Vue/test/unit/features/directives/if.spec.js
deleted file mode 100644
index 458f1f9..0000000
--- a/1.Vue/test/unit/features/directives/if.spec.js
+++ /dev/null
@@ -1,276 +0,0 @@
-import Vue from 'vue'
-
-describe('Directive v-if', () => {
-  it('should check if value is truthy', () => {
-    const vm = new Vue({
-      template: '<div><span v-if="foo">hello</span></div>',
-      data: { foo: true }
-    }).$mount()
-    expect(vm.$el.innerHTML).toBe('<span>hello</span>')
-  })
-
-  it('should check if value is falsy', () => {
-    const vm = new Vue({
-      template: '<div><span v-if="foo">hello</span></div>',
-      data: { foo: false }
-    }).$mount()
-    expect(vm.$el.innerHTML).toBe('<!---->')
-  })
-
-  it('should update if value changed', done => {
-    const vm = new Vue({
-      template: '<div><span v-if="foo">hello</span></div>',
-      data: { foo: true }
-    }).$mount()
-    expect(vm.$el.innerHTML).toBe('<span>hello</span>')
-    vm.foo = false
-    waitForUpdate(() => {
-      expect(vm.$el.innerHTML).toBe('<!---->')
-      vm.foo = {}
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<span>hello</span>')
-      vm.foo = 0
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<!---->')
-      vm.foo = []
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<span>hello</span>')
-      vm.foo = null
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<!---->')
-      vm.foo = '0'
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<span>hello</span>')
-      vm.foo = undefined
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<!---->')
-      vm.foo = 1
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<span>hello</span>')
-    }).then(done)
-  })
-
-  it('should work well with v-else', done => {
-    const vm = new Vue({
-      template: `
-        <div>
-          <span v-if="foo">hello</span>
-          <span v-else>bye</span>
-        </div>
-      `,
-      data: { foo: true }
-    }).$mount()
-    expect(vm.$el.innerHTML.trim()).toBe('<span>hello</span>')
-    vm.foo = false
-    waitForUpdate(() => {
-      expect(vm.$el.innerHTML.trim()).toBe('<span>bye</span>')
-      vm.foo = {}
-    }).then(() => {
-      expect(vm.$el.innerHTML.trim()).toBe('<span>hello</span>')
-      vm.foo = 0
-    }).then(() => {
-      expect(vm.$el.innerHTML.trim()).toBe('<span>bye</span>')
-      vm.foo = []
-    }).then(() => {
-      expect(vm.$el.innerHTML.trim()).toBe('<span>hello</span>')
-      vm.foo = null
-    }).then(() => {
-      expect(vm.$el.innerHTML.trim()).toBe('<span>bye</span>')
-      vm.foo = '0'
-    }).then(() => {
-      expect(vm.$el.innerHTML.trim()).toBe('<span>hello</span>')
-      vm.foo = undefined
-    }).then(() => {
-      expect(vm.$el.innerHTML.trim()).toBe('<span>bye</span>')
-      vm.foo = 1
-    }).then(() => {
-      expect(vm.$el.innerHTML.trim()).toBe('<span>hello</span>')
-    }).then(done)
-  })
-
-  it('should work well with v-else-if', done => {
-    const vm = new Vue({
-      template: `
-        <div>
-          <span v-if="foo">hello</span>
-          <span v-else-if="bar">elseif</span>
-          <span v-else>bye</span>
-        </div>
-      `,
-      data: { foo: true, bar: false }
-    }).$mount()
-    expect(vm.$el.innerHTML.trim()).toBe('<span>hello</span>')
-    vm.foo = false
-    waitForUpdate(() => {
-      expect(vm.$el.innerHTML.trim()).toBe('<span>bye</span>')
-      vm.bar = true
-    }).then(() => {
-      expect(vm.$el.innerHTML.trim()).toBe('<span>elseif</span>')
-      vm.bar = false
-    }).then(() => {
-      expect(vm.$el.innerHTML.trim()).toBe('<span>bye</span>')
-      vm.foo = true
-    }).then(() => {
-      expect(vm.$el.innerHTML.trim()).toBe('<span>hello</span>')
-      vm.foo = false
-      vm.bar = {}
-    }).then(() => {
-      expect(vm.$el.innerHTML.trim()).toBe('<span>elseif</span>')
-      vm.bar = 0
-    }).then(() => {
-      expect(vm.$el.innerHTML.trim()).toBe('<span>bye</span>')
-      vm.bar = []
-    }).then(() => {
-      expect(vm.$el.innerHTML.trim()).toBe('<span>elseif</span>')
-      vm.bar = null
-    }).then(() => {
-      expect(vm.$el.innerHTML.trim()).toBe('<span>bye</span>')
-      vm.bar = '0'
-    }).then(() => {
-      expect(vm.$el.innerHTML.trim()).toBe('<span>elseif</span>')
-      vm.bar = undefined
-    }).then(() => {
-      expect(vm.$el.innerHTML.trim()).toBe('<span>bye</span>')
-      vm.bar = 1
-    }).then(() => {
-      expect(vm.$el.innerHTML.trim()).toBe('<span>elseif</span>')
-    }).then(done)
-  })
-
-  it('should work well with v-for', done => {
-    const vm = new Vue({
-      template: `
-        <div>
-          <span v-for="(item, i) in list" v-if="item.value">{{i}}</span>
-        </div>
-      `,
-      data: {
-        list: [
-          { value: true },
-          { value: false },
-          { value: true }
-        ]
-      }
-    }).$mount()
-    expect(vm.$el.innerHTML).toBe('<span>0</span><!----><span>2</span>')
-    vm.list[0].value = false
-    waitForUpdate(() => {
-      expect(vm.$el.innerHTML).toBe('<!----><!----><span>2</span>')
-      vm.list.push({ value: true })
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<!----><!----><span>2</span><span>3</span>')
-      vm.list.splice(1, 2)
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<!----><span>1</span>')
-    }).then(done)
-  })
-
-  it('should work well with v-for and v-else', done => {
-    const vm = new Vue({
-      template: `
-        <div>
-          <span v-for="(item, i) in list" v-if="item.value">hello</span>
-          <span v-else>bye</span>
-        </div>
-      `,
-      data: {
-        list: [
-          { value: true },
-          { value: false },
-          { value: true }
-        ]
-      }
-    }).$mount()
-    expect(vm.$el.innerHTML.trim()).toBe('<span>hello</span><span>bye</span><span>hello</span>')
-    vm.list[0].value = false
-    waitForUpdate(() => {
-      expect(vm.$el.innerHTML.trim()).toBe('<span>bye</span><span>bye</span><span>hello</span>')
-      vm.list.push({ value: true })
-    }).then(() => {
-      expect(vm.$el.innerHTML.trim()).toBe('<span>bye</span><span>bye</span><span>hello</span><span>hello</span>')
-      vm.list.splice(1, 2)
-    }).then(() => {
-      expect(vm.$el.innerHTML.trim()).toBe('<span>bye</span><span>hello</span>')
-    }).then(done)
-  })
-
-  it('should work with v-for on v-else branch', done => {
-    const vm = new Vue({
-      template: `
-        <div>
-          <span v-if="false">hello</span>
-          <span v-else v-for="item in list">{{ item }}</span>
-        </div>
-      `,
-      data: {
-        list: [1, 2, 3]
-      }
-    }).$mount()
-    expect(vm.$el.textContent.trim()).toBe('123')
-    vm.list.reverse()
-    waitForUpdate(() => {
-      expect(vm.$el.textContent.trim()).toBe('321')
-    }).then(done)
-  })
-
-  it('should work properly on component root', done => {
-    const vm = new Vue({
-      template: `
-        <div>
-          <test class="test"></test>
-        </div>
-      `,
-      components: {
-        test: {
-          data () {
-            return { ok: true }
-          },
-          template: '<div v-if="ok" id="ok" class="inner">test</div>'
-        }
-      }
-    }).$mount()
-    expect(vm.$el.children[0].id).toBe('ok')
-    expect(vm.$el.children[0].className).toBe('inner test')
-    vm.$children[0].ok = false
-    waitForUpdate(() => {
-      // attrs / class modules should not attempt to patch the comment node
-      expect(vm.$el.innerHTML).toBe('<!---->')
-      vm.$children[0].ok = true
-    }).then(() => {
-      expect(vm.$el.children[0].id).toBe('ok')
-      expect(vm.$el.children[0].className).toBe('inner test')
-    }).then(done)
-  })
-
-  it('should maintain stable list to avoid unnecessary patches', done => {
-    const created = jasmine.createSpy()
-    const destroyed = jasmine.createSpy()
-    const vm = new Vue({
-      data: {
-        ok: true
-      },
-      // when the first div is toggled, the second div should be reused
-      // instead of re-created/destroyed
-      template: `
-        <div>
-          <div v-if="ok"></div>
-          <div><test></test></div>
-        </div>
-      `,
-      components: {
-        test: {
-          template: '<div></div>',
-          created,
-          destroyed
-        }
-      }
-    }).$mount()
-
-    expect(created.calls.count()).toBe(1)
-    vm.ok = false
-    waitForUpdate(() => {
-      expect(created.calls.count()).toBe(1)
-      expect(destroyed).not.toHaveBeenCalled()
-    }).then(done)
-  })
-})
diff --git a/1.Vue/test/unit/features/directives/model-checkbox.spec.js b/1.Vue/test/unit/features/directives/model-checkbox.spec.js
deleted file mode 100644
index 0d6ba2f..0000000
--- a/1.Vue/test/unit/features/directives/model-checkbox.spec.js
+++ /dev/null
@@ -1,367 +0,0 @@
-import Vue from 'vue'
-
-describe('Directive v-model checkbox', () => {
-  it('should work', done => {
-    const vm = new Vue({
-      data: {
-        test: true
-      },
-      template: '<input type="checkbox" v-model="test">'
-    }).$mount()
-    document.body.appendChild(vm.$el)
-    expect(vm.$el.checked).toBe(true)
-    vm.test = false
-    waitForUpdate(function () {
-      expect(vm.$el.checked).toBe(false)
-      expect(vm.test).toBe(false)
-      vm.$el.click()
-      expect(vm.$el.checked).toBe(true)
-      expect(vm.test).toBe(true)
-    }).then(() => {
-      document.body.removeChild(vm.$el)
-    }).then(done)
-  })
-
-  it('should respect value bindings', done => {
-    const vm = new Vue({
-      data: {
-        test: 1,
-        a: 1,
-        b: 2
-      },
-      template: '<input type="checkbox" v-model="test" :true-value="a" :false-value="b">'
-    }).$mount()
-    document.body.appendChild(vm.$el)
-    expect(vm.$el.checked).toBe(true)
-    vm.$el.click()
-    expect(vm.$el.checked).toBe(false)
-    expect(vm.test).toBe(2)
-    vm.$el.click()
-    expect(vm.$el.checked).toBe(true)
-    expect(vm.test).toBe(1)
-    vm.test = 2
-    waitForUpdate(() => {
-      expect(vm.$el.checked).toBe(false)
-      vm.test = 1
-    }).then(() => {
-      expect(vm.$el.checked).toBe(true)
-      document.body.removeChild(vm.$el)
-    }).then(done)
-  })
-
-  it('bind to Array value', done => {
-    const vm = new Vue({
-      data: {
-        test: ['1']
-      },
-      template: `
-        <div>
-          {{ test }}
-          <input type="checkbox" v-model="test" value="1">
-          <input type="checkbox" v-model="test" value="2">
-        </div>
-      `
-    }).$mount()
-    document.body.appendChild(vm.$el)
-    expect(vm.$el.children[0].checked).toBe(true)
-    expect(vm.$el.children[1].checked).toBe(false)
-    vm.$el.children[0].click()
-    waitForUpdate(() => {
-      expect(vm.test.length).toBe(0)
-      vm.$el.children[1].click()
-    }).then(() => {
-      expect(vm.test).toEqual(['2'])
-      vm.$el.children[0].click()
-    }).then(() => {
-      expect(vm.test).toEqual(['2', '1'])
-      vm.test = ['1']
-    }).then(() => {
-      expect(vm.$el.children[0].checked).toBe(true)
-      expect(vm.$el.children[1].checked).toBe(false)
-    }).then(done)
-  })
-
-  it('bind to Array value ignores false-value', done => {
-    const vm = new Vue({
-      data: {
-        test: ['1']
-      },
-      template: `
-        <div>
-          <input type="checkbox" v-model="test" value="1" :false-value="true">
-          <input type="checkbox" v-model="test" value="2" :false-value="true">
-        </div>
-      `
-    }).$mount()
-    document.body.appendChild(vm.$el)
-    expect(vm.$el.children[0].checked).toBe(true)
-    expect(vm.$el.children[1].checked).toBe(false)
-    vm.$el.children[0].click()
-    waitForUpdate(() => {
-      expect(vm.test.length).toBe(0)
-      vm.$el.children[1].click()
-    }).then(() => {
-      expect(vm.test).toEqual(['2'])
-      vm.$el.children[0].click()
-    }).then(() => {
-      expect(vm.test).toEqual(['2', '1'])
-      vm.test = ['1']
-    }).then(() => {
-      expect(vm.$el.children[0].checked).toBe(true)
-      expect(vm.$el.children[1].checked).toBe(false)
-    }).then(done)
-  })
-
-  it('bind to Array value with value bindings', done => {
-    const vm = new Vue({
-      data: {
-        test: [1]
-      },
-      template: `
-        <div>
-          <input type="checkbox" v-model="test" :value="1">
-          <input type="checkbox" v-model="test" :value="2">
-        </div>
-      `
-    }).$mount()
-    document.body.appendChild(vm.$el)
-    expect(vm.$el.children[0].checked).toBe(true)
-    expect(vm.$el.children[1].checked).toBe(false)
-    vm.$el.children[0].click()
-    waitForUpdate(() => {
-      expect(vm.test.length).toBe(0)
-      vm.$el.children[1].click()
-    }).then(() => {
-      expect(vm.test).toEqual([2])
-      vm.$el.children[0].click()
-    }).then(() => {
-      expect(vm.test).toEqual([2, 1])
-      vm.test = [1]
-    }).then(() => {
-      expect(vm.$el.children[0].checked).toBe(true)
-      expect(vm.$el.children[1].checked).toBe(false)
-    }).then(done)
-  })
-
-  it('bind to Array value with value bindings (object loose equal)', done => {
-    const vm = new Vue({
-      data: {
-        test: [{ a: 1 }]
-      },
-      template: `
-        <div>
-          <input type="checkbox" v-model="test" :value="{ a: 1 }">
-          <input type="checkbox" v-model="test" :value="{ a: 2 }">
-        </div>
-      `
-    }).$mount()
-    document.body.appendChild(vm.$el)
-    expect(vm.$el.children[0].checked).toBe(true)
-    expect(vm.$el.children[1].checked).toBe(false)
-    vm.$el.children[0].click()
-    waitForUpdate(() => {
-      expect(vm.test.length).toBe(0)
-      vm.$el.children[1].click()
-    }).then(() => {
-      expect(vm.test).toEqual([{ a: 2 }])
-      vm.$el.children[0].click()
-    }).then(() => {
-      expect(vm.test).toEqual([{ a: 2 }, { a: 1 }])
-      vm.test = [{ a: 1 }]
-    }).then(() => {
-      expect(vm.$el.children[0].checked).toBe(true)
-      expect(vm.$el.children[1].checked).toBe(false)
-    }).then(done)
-  })
-
-  it('bind to Array value with array value bindings (object loose equal)', done => {
-    const vm = new Vue({
-      data: {
-        test: [{ a: 1 }]
-      },
-      template: `
-        <div>
-          <input type="checkbox" v-model="test" :value="{ a: 1 }">
-          <input type="checkbox" v-model="test" :value="[2]">
-        </div>
-      `
-    }).$mount()
-    document.body.appendChild(vm.$el)
-    expect(vm.$el.children[0].checked).toBe(true)
-    expect(vm.$el.children[1].checked).toBe(false)
-    vm.$el.children[0].click()
-    waitForUpdate(() => {
-      expect(vm.test.length).toBe(0)
-      vm.$el.children[1].click()
-    }).then(() => {
-      expect(vm.test).toEqual([[2]])
-      vm.$el.children[0].click()
-    }).then(() => {
-      expect(vm.test).toEqual([[2], { a: 1 }])
-      vm.test = [{ a: 1 }]
-    }).then(() => {
-      expect(vm.$el.children[0].checked).toBe(true)
-      expect(vm.$el.children[1].checked).toBe(false)
-    }).then(done)
-  })
-
-  it('.number modifier', () => {
-    const vm = new Vue({
-      data: {
-        test: [],
-        check: true
-      },
-      template: `
-        <div>
-          <input type="checkbox" v-model.number="test" value="1">
-          <input type="checkbox" v-model="test" value="2">
-          <input type="checkbox" v-model.number="check">
-        </div>
-      `
-    }).$mount()
-    document.body.appendChild(vm.$el)
-    const checkboxInputs = vm.$el.getElementsByTagName('input')
-    expect(checkboxInputs[0].checked).toBe(false)
-    expect(checkboxInputs[1].checked).toBe(false)
-    expect(checkboxInputs[2].checked).toBe(true)
-    checkboxInputs[0].click()
-    checkboxInputs[1].click()
-    checkboxInputs[2].click()
-    expect(vm.test).toEqual([1, '2'])
-    expect(vm.check).toEqual(false)
-  })
-
-  it('should respect different primitive type value', (done) => {
-    const vm = new Vue({
-      data: {
-        test: [0]
-      },
-      template:
-        '<div>' +
-          '<input type="checkbox" value="" v-model="test">' +
-          '<input type="checkbox" value="0" v-model="test">' +
-          '<input type="checkbox" value="1" v-model="test">' +
-          '<input type="checkbox" value="false" v-model="test">' +
-          '<input type="checkbox" value="true" v-model="test">' +
-        '</div>'
-    }).$mount()
-    const checkboxInput = vm.$el.children
-    expect(checkboxInput[0].checked).toBe(false)
-    expect(checkboxInput[1].checked).toBe(true)
-    expect(checkboxInput[2].checked).toBe(false)
-    expect(checkboxInput[3].checked).toBe(false)
-    expect(checkboxInput[4].checked).toBe(false)
-    vm.test = [1]
-    waitForUpdate(() => {
-      expect(checkboxInput[0].checked).toBe(false)
-      expect(checkboxInput[1].checked).toBe(false)
-      expect(checkboxInput[2].checked).toBe(true)
-      expect(checkboxInput[3].checked).toBe(false)
-      expect(checkboxInput[4].checked).toBe(false)
-      vm.test = ['']
-    }).then(() => {
-      expect(checkboxInput[0].checked).toBe(true)
-      expect(checkboxInput[1].checked).toBe(false)
-      expect(checkboxInput[2].checked).toBe(false)
-      expect(checkboxInput[3].checked).toBe(false)
-      expect(checkboxInput[4].checked).toBe(false)
-      vm.test = [false]
-    }).then(() => {
-      expect(checkboxInput[0].checked).toBe(false)
-      expect(checkboxInput[1].checked).toBe(false)
-      expect(checkboxInput[2].checked).toBe(false)
-      expect(checkboxInput[3].checked).toBe(true)
-      expect(checkboxInput[4].checked).toBe(false)
-      vm.test = [true]
-    }).then(() => {
-      expect(checkboxInput[0].checked).toBe(false)
-      expect(checkboxInput[1].checked).toBe(false)
-      expect(checkboxInput[2].checked).toBe(false)
-      expect(checkboxInput[3].checked).toBe(false)
-      expect(checkboxInput[4].checked).toBe(true)
-      vm.test = ['', 0, 1, false, true]
-    }).then(() => {
-      expect(checkboxInput[0].checked).toBe(true)
-      expect(checkboxInput[1].checked).toBe(true)
-      expect(checkboxInput[2].checked).toBe(true)
-      expect(checkboxInput[3].checked).toBe(true)
-      expect(checkboxInput[4].checked).toBe(true)
-    }).then(done)
-  })
-
-  // #4521
-  it('should work with click event', (done) => {
-    const vm = new Vue({
-      data: {
-        num: 1,
-        checked: false
-      },
-      template: '<div @click="add">click {{ num }}<input ref="checkbox" type="checkbox" v-model="checked"/></div>',
-      methods: {
-        add: function () {
-          this.num++
-        }
-      }
-    }).$mount()
-    document.body.appendChild(vm.$el)
-    const checkbox = vm.$refs.checkbox
-    checkbox.click()
-    waitForUpdate(() => {
-      expect(checkbox.checked).toBe(true)
-      expect(vm.num).toBe(2)
-    }).then(done)
-  })
-
-  it('should get updated with model when in focus', (done) => {
-    const vm = new Vue({
-      data: {
-        a: 2
-      },
-      template: '<input type="checkbox" v-model="a"/>'
-    }).$mount()
-    document.body.appendChild(vm.$el)
-    vm.$el.click()
-    waitForUpdate(() => {
-      expect(vm.$el.checked).toBe(false)
-      vm.a = 2
-    }).then(() => {
-      expect(vm.$el.checked).toBe(true)
-    }).then(done)
-  })
-
-  it('triggers a watcher when binding to an array value in a checkbox', done => {
-    const vm = new Vue({
-      data: {
-        test: {
-          thing: false,
-          arr: [true]
-        }
-      },
-      template: `
-        <div>
-          <input type="checkbox" v-model="test.arr[0]">
-          <span>{{ test.arr[0] }}</span>
-        </div>
-      `
-    }).$mount()
-    document.body.appendChild(vm.$el)
-    expect(vm.$el.children[0].checked).toBe(true)
-    expect(vm.$el.children[1].textContent).toBe('true')
-    vm.$el.children[0].click()
-    expect(vm.$el.children[0].checked).toBe(false)
-    waitForUpdate(() => {
-      expect(vm.$el.children[1].textContent).toBe('false')
-    }).then(done)
-  })
-
-  // #7811
-  it('type should not be overwritten by v-bind', () => {
-    const vm = new Vue({
-      data: {
-        test: true
-      },
-      template: '<input type="checkbox" v-model="test" v-bind="$attrs">'
-    }).$mount()
-    expect(vm.$el.type).toBe('checkbox')
-  })
-})
diff --git a/1.Vue/test/unit/features/directives/model-component.spec.js b/1.Vue/test/unit/features/directives/model-component.spec.js
deleted file mode 100644
index 49ff4dd..0000000
--- a/1.Vue/test/unit/features/directives/model-component.spec.js
+++ /dev/null
@@ -1,233 +0,0 @@
-import Vue from 'vue'
-
-describe('Directive v-model component', () => {
-  it('should work', done => {
-    const vm = new Vue({
-      data: {
-        msg: 'hello'
-      },
-      template: `
-        <div>
-          <p>{{ msg }}</p>
-          <test v-model="msg"></test>
-        </div>
-      `,
-      components: {
-        test: {
-          props: ['value'],
-          template: `<input :value="value" @input="$emit('input', $event.target.value)">`
-        }
-      }
-    }).$mount()
-    document.body.appendChild(vm.$el)
-    waitForUpdate(() => {
-      const input = vm.$el.querySelector('input')
-      input.value = 'world'
-      triggerEvent(input, 'input')
-    }).then(() => {
-      expect(vm.msg).toEqual('world')
-      expect(vm.$el.querySelector('p').textContent).toEqual('world')
-      vm.msg = 'changed'
-    }).then(() => {
-      expect(vm.$el.querySelector('p').textContent).toEqual('changed')
-      expect(vm.$el.querySelector('input').value).toEqual('changed')
-    }).then(() => {
-      document.body.removeChild(vm.$el)
-    }).then(done)
-  })
-
-  it('should work with native tags with "is"', done => {
-    const vm = new Vue({
-      data: {
-        msg: 'hello'
-      },
-      template: `
-        <div>
-          <p>{{ msg }}</p>
-          <input is="test" v-model="msg">
-        </div>
-      `,
-      components: {
-        test: {
-          props: ['value'],
-          template: `<input :value="value" @input="$emit('input', $event.target.value)">`
-        }
-      }
-    }).$mount()
-    document.body.appendChild(vm.$el)
-    waitForUpdate(() => {
-      const input = vm.$el.querySelector('input')
-      input.value = 'world'
-      triggerEvent(input, 'input')
-    }).then(() => {
-      expect(vm.msg).toEqual('world')
-      expect(vm.$el.querySelector('p').textContent).toEqual('world')
-      vm.msg = 'changed'
-    }).then(() => {
-      expect(vm.$el.querySelector('p').textContent).toEqual('changed')
-      expect(vm.$el.querySelector('input').value).toEqual('changed')
-    }).then(() => {
-      document.body.removeChild(vm.$el)
-    }).then(done)
-  })
-
-  it('should support customization via model option', done => {
-    const spy = jasmine.createSpy('update')
-    const vm = new Vue({
-      data: {
-        msg: 'hello'
-      },
-      methods: {
-        spy
-      },
-      template: `
-        <div>
-          <p>{{ msg }}</p>
-          <test v-model="msg" @update="spy"></test>
-        </div>
-      `,
-      components: {
-        test: {
-          model: {
-            prop: 'currentValue',
-            event: 'update'
-          },
-          props: ['currentValue'],
-          template: `<input :value="currentValue" @input="$emit('update', $event.target.value)">`
-        }
-      }
-    }).$mount()
-    document.body.appendChild(vm.$el)
-    waitForUpdate(() => {
-      const input = vm.$el.querySelector('input')
-      input.value = 'world'
-      triggerEvent(input, 'input')
-    }).then(() => {
-      expect(vm.msg).toEqual('world')
-      expect(vm.$el.querySelector('p').textContent).toEqual('world')
-      expect(spy).toHaveBeenCalledWith('world')
-      vm.msg = 'changed'
-    }).then(() => {
-      expect(vm.$el.querySelector('p').textContent).toEqual('changed')
-      expect(vm.$el.querySelector('input').value).toEqual('changed')
-    }).then(() => {
-      document.body.removeChild(vm.$el)
-    }).then(done)
-  })
-
-  it('modifier: .number', () => {
-    const vm = new Vue({
-      template: `<div><my-input ref="input" v-model.number="text"></my-input></div>`,
-      data: { text: 'foo' },
-      components: {
-        'my-input': {
-          template: '<input>'
-        }
-      }
-    }).$mount()
-    expect(vm.text).toBe('foo')
-    vm.$refs.input.$emit('input', 'bar')
-    expect(vm.text).toBe('bar')
-    vm.$refs.input.$emit('input', '123')
-    expect(vm.text).toBe(123)
-  })
-
-  it('modifier: .trim', () => {
-    const vm = new Vue({
-      template: `<div><my-input ref="input" v-model.trim="text"></my-input></div>`,
-      data: { text: 'foo' },
-      components: {
-        'my-input': {
-          template: '<input>'
-        }
-      }
-    }).$mount()
-    expect(vm.text).toBe('foo')
-    vm.$refs.input.$emit('input', '  bar  ')
-    expect(vm.text).toBe('bar')
-    vm.$refs.input.$emit('input', '   foo o  ')
-    expect(vm.text).toBe('foo o')
-  })
-
-  // #8436
-  it('should not double transform mode props', () => {
-    const BaseInput = {
-      props: ['value'],
-      render (h) {
-        return h('input', {
-          domProps: {
-            value: this.value
-          },
-          on: {
-            input: e => this.$emit('input', e.target.value)
-          }
-        })
-      }
-    }
-
-    const FunctionalWrapper = {
-      functional: true,
-      render (h, ctx) {
-        return h(BaseInput, ctx.data)
-      }
-    }
-
-    let triggerCount = 0
-
-    const vm = new Vue({
-      components: {
-        FunctionalWrapper
-      },
-      template: `
-        <div>
-          <functional-wrapper v-model="val"/>
-        </div>
-      `,
-      data: {
-        internalVal: ''
-      },
-      computed: {
-        val: {
-          get () {
-            return this.internalVal
-          },
-          set (val) {
-            triggerCount++
-            this.internalVal = val
-          }
-        }
-      }
-    }).$mount()
-
-    document.body.appendChild(vm.$el)
-    triggerEvent(vm.$el.querySelector('input'), 'input')
-    expect(triggerCount).toBe(1)
-    document.body.removeChild(vm.$el)
-  })
-
-  // #9330
-  it('should add value to $attrs if not defined in props', () => {
-    const TestComponent = {
-      inheritAttrs: false,
-      render (h) {
-        return h('div', this.$attrs.value)
-      }
-    }
-
-    const vm = new Vue({
-      components: {
-        TestComponent
-      },
-      template: `
-        <div>
-          <test-component v-model="val"/>
-        </div>
-      `,
-      data: {
-        val: 'foo'
-      }
-    }).$mount()
-
-    expect(vm.$el.innerHTML).toBe('<div>foo</div>');
-  })
-})
diff --git a/1.Vue/test/unit/features/directives/model-dynamic.spec.js b/1.Vue/test/unit/features/directives/model-dynamic.spec.js
deleted file mode 100644
index 88a910f..0000000
--- a/1.Vue/test/unit/features/directives/model-dynamic.spec.js
+++ /dev/null
@@ -1,218 +0,0 @@
-import Vue from 'vue'
-
-describe('Directive v-model dynamic input type', () => {
-  it('should work', done => {
-    const vm = new Vue({
-      data: {
-        inputType: null,
-        test: 'b'
-      },
-      template: `<input :type="inputType" v-model="test">`
-    }).$mount()
-    document.body.appendChild(vm.$el)
-
-    // test text
-    assertInputWorks(vm, 'inputType').then(done)
-  })
-
-  it('with v-if', done => {
-    const vm = new Vue({
-      data: {
-        ok: true,
-        type: null,
-        test: 'b'
-      },
-      template: `<input v-if="ok" :type="type" v-model="test"><div v-else>haha</div>`
-    }).$mount()
-    document.body.appendChild(vm.$el)
-
-    const chain = assertInputWorks(vm).then(() => {
-      vm.ok = false
-    }).then(() => {
-      expect(vm.$el.textContent).toBe('haha')
-    }).then(() => {
-      // reset
-      vm.ok = true
-      vm.type = null
-      vm.test = 'b'
-    })
-
-    assertInputWorks(vm, chain).then(done)
-  })
-
-  it('with v-else', done => {
-    const data = {
-      ok: true,
-      type: null,
-      test: 'b'
-    }
-    const vm = new Vue({
-      data,
-      template: `<div v-if="ok">haha</div><input v-else :type="type" v-model="test">`
-    }).$mount()
-    document.body.appendChild(vm.$el)
-    expect(vm.$el.textContent).toBe('haha')
-
-    vm.ok = false
-    assertInputWorks(vm).then(done)
-  })
-
-  it('with v-else-if', done => {
-    const vm = new Vue({
-      data: {
-        foo: true,
-        bar: false,
-        type: null,
-        test: 'b'
-      },
-      template: `<div v-if="foo">text</div><input v-else-if="bar" :type="type" v-model="test">`
-    }).$mount()
-    document.body.appendChild(vm.$el)
-
-    const chain = waitForUpdate(() => {
-      expect(vm.$el.textContent).toBe('text')
-    }).then(() => {
-      vm.foo = false
-    }).then(() => {
-      expect(vm._vnode.isComment).toBe(true)
-    }).then(() => {
-      vm.bar = true
-    })
-
-    assertInputWorks(vm, chain).then(done)
-  })
-
-  it('with v-for', done => {
-    const vm = new Vue({
-      data: {
-        data: {
-          text: 'foo',
-          checkbox: true
-        },
-        types: ['text', 'checkbox']
-      },
-      template: `<div>
-        <input v-for="type in types" :type="type" v-model="data[type]">
-      </div>`
-    }).$mount()
-    document.body.appendChild(vm.$el)
-
-    let el1 = vm.$el.children[0]
-    expect(el1.type).toBe('text')
-    expect(el1.value).toBe('foo')
-    el1.value = 'bar'
-    triggerEvent(el1, 'input')
-    expect(vm.data.text).toBe('bar')
-
-    let el2 = vm.$el.children[1]
-    expect(el2.type).toBe('checkbox')
-    expect(el2.checked).toBe(true)
-    el2.click()
-    expect(vm.data.checkbox).toBe(false)
-
-    // now in reverse!
-    vm.types.reverse()
-    waitForUpdate(() => {
-      el1 = vm.$el.children[0]
-      expect(el1.type).toBe('checkbox')
-      expect(el1.checked).toBe(false)
-      el1.click()
-      expect(vm.data.checkbox).toBe(true)
-
-      el2 = vm.$el.children[1]
-      expect(el2.type).toBe('text')
-      expect(el2.value).toBe('bar')
-      el2.value = 'foo'
-      triggerEvent(el2, 'input')
-      expect(vm.data.text).toBe('foo')
-    }).then(done)
-  })
-
-  it('with v-bind', done => {
-    const vm = new Vue({
-      data: {
-        data: {
-          text: 'foo',
-          checkbox: true
-        },
-        inputs: [{ id: 'one', type: 'text' }, { id: 'two', type: 'checkbox' }]
-      },
-      template: `<div>
-        <input v-for="i in inputs" v-bind="i" v-model="data[i.type]">
-      </div>`
-    }).$mount()
-    document.body.appendChild(vm.$el)
-
-    let el1 = vm.$el.children[0]
-    expect(el1.id).toBe('one')
-    expect(el1.type).toBe('text')
-    expect(el1.value).toBe('foo')
-    el1.value = 'bar'
-    triggerEvent(el1, 'input')
-    expect(vm.data.text).toBe('bar')
-
-    let el2 = vm.$el.children[1]
-    expect(el2.id).toBe('two')
-    expect(el2.type).toBe('checkbox')
-    expect(el2.checked).toBe(true)
-    el2.click()
-    expect(vm.data.checkbox).toBe(false)
-
-    // now in reverse!
-    vm.inputs.reverse()
-    waitForUpdate(() => {
-      el1 = vm.$el.children[0]
-      expect(el1.id).toBe('two')
-      expect(el1.type).toBe('checkbox')
-      expect(el1.checked).toBe(false)
-      el1.click()
-      expect(vm.data.checkbox).toBe(true)
-
-      el2 = vm.$el.children[1]
-      expect(el2.id).toBe('one')
-      expect(el2.type).toBe('text')
-      expect(el2.value).toBe('bar')
-      el2.value = 'foo'
-      triggerEvent(el2, 'input')
-      expect(vm.data.text).toBe('foo')
-    }).then(done)
-  })
-})
-
-function assertInputWorks (vm, type, chain) {
-  if (typeof type !== 'string') {
-    if (!chain) chain = type
-    type = 'type'
-  }
-  if (!chain) chain = waitForUpdate()
-  chain.then(() => {
-    expect(vm.$el.value).toBe('b')
-    vm.test = 'a'
-  }).then(() => {
-    expect(vm.$el.value).toBe('a')
-    vm.$el.value = 'c'
-    triggerEvent(vm.$el, 'input')
-    expect(vm.test).toBe('c')
-  }).then(() => {
-    // change it to password
-    vm[type] = 'password'
-    vm.test = 'b'
-  }).then(() => {
-    expect(vm.$el.type).toBe('password')
-    expect(vm.$el.value).toBe('b')
-    vm.$el.value = 'c'
-    triggerEvent(vm.$el, 'input')
-    expect(vm.test).toBe('c')
-  }).then(() => {
-    // change it to checkbox...
-    vm[type] = 'checkbox'
-  }).then(() => {
-    expect(vm.$el.type).toBe('checkbox')
-    expect(vm.$el.checked).toBe(true)
-  }).then(() => {
-    vm.$el.click()
-    expect(vm.$el.checked).toBe(false)
-    expect(vm.test).toBe(false)
-  })
-  return chain
-}
diff --git a/1.Vue/test/unit/features/directives/model-file.spec.js b/1.Vue/test/unit/features/directives/model-file.spec.js
deleted file mode 100644
index 8c92ab7..0000000
--- a/1.Vue/test/unit/features/directives/model-file.spec.js
+++ /dev/null
@@ -1,13 +0,0 @@
-import Vue from 'vue'
-
-describe('Directive v-model file', () => {
-  it('warn to use @change instead', () => {
-    new Vue({
-      data: {
-        file: ''
-      },
-      template: '<input v-model="file" type="file">'
-    }).$mount()
-    expect('Use a v-on:change listener instead').toHaveBeenWarned()
-  })
-})
diff --git a/1.Vue/test/unit/features/directives/model-parse.spec.js b/1.Vue/test/unit/features/directives/model-parse.spec.js
deleted file mode 100644
index f9c48a6..0000000
--- a/1.Vue/test/unit/features/directives/model-parse.spec.js
+++ /dev/null
@@ -1,39 +0,0 @@
-import { parseModel } from 'compiler/directives/model'
-
-describe('model expression parser', () => {
-  it('parse single path', () => {
-    const res = parseModel('foo')
-    expect(res.exp).toBe('foo')
-    expect(res.key).toBe(null)
-  })
-
-  it('parse object dot notation', () => {
-    const res = parseModel('a.b.c')
-    expect(res.exp).toBe('a.b')
-    expect(res.key).toBe('"c"')
-  })
-
-  it('parse string in brackets', () => {
-    const res = parseModel('a["b"][c]')
-    expect(res.exp).toBe('a["b"]')
-    expect(res.key).toBe('c')
-  })
-
-  it('parse brackets with object dot notation', () => {
-    const res = parseModel('a["b"][c].xxx')
-    expect(res.exp).toBe('a["b"][c]')
-    expect(res.key).toBe('"xxx"')
-  })
-
-  it('parse nested brackets', () => {
-    const res = parseModel('a[i[c]]')
-    expect(res.exp).toBe('a')
-    expect(res.key).toBe('i[c]')
-  })
-
-  it('combined', () => {
-    const res = parseModel('test.xxx.a["asa"][test1[key]]')
-    expect(res.exp).toBe('test.xxx.a["asa"]')
-    expect(res.key).toBe('test1[key]')
-  })
-})
diff --git a/1.Vue/test/unit/features/directives/model-radio.spec.js b/1.Vue/test/unit/features/directives/model-radio.spec.js
deleted file mode 100644
index 3ff4e50..0000000
--- a/1.Vue/test/unit/features/directives/model-radio.spec.js
+++ /dev/null
@@ -1,254 +0,0 @@
-import Vue from 'vue'
-
-describe('Directive v-model radio', () => {
-  it('should work', done => {
-    const vm = new Vue({
-      data: {
-        test: '1'
-      },
-      template: `
-        <div>
-          <input type="radio" value="1" v-model="test" name="test">
-          <input type="radio" value="2" v-model="test" name="test">
-        </div>
-      `
-    }).$mount()
-    document.body.appendChild(vm.$el)
-    expect(vm.$el.children[0].checked).toBe(true)
-    expect(vm.$el.children[1].checked).toBe(false)
-    vm.test = '2'
-    waitForUpdate(() => {
-      expect(vm.$el.children[0].checked).toBe(false)
-      expect(vm.$el.children[1].checked).toBe(true)
-      vm.$el.children[0].click()
-      expect(vm.$el.children[0].checked).toBe(true)
-      expect(vm.$el.children[1].checked).toBe(false)
-      expect(vm.test).toBe('1')
-    }).then(() => {
-      document.body.removeChild(vm.$el)
-    }).then(done)
-  })
-
-  it('should respect value bindings', done => {
-    const vm = new Vue({
-      data: {
-        test: 1
-      },
-      template: `
-        <div>
-          <input type="radio" :value="1" v-model="test" name="test">
-          <input type="radio" :value="2" v-model="test" name="test">
-        </div>
-      `
-    }).$mount()
-    document.body.appendChild(vm.$el)
-    expect(vm.$el.children[0].checked).toBe(true)
-    expect(vm.$el.children[1].checked).toBe(false)
-    vm.test = 2
-    waitForUpdate(() => {
-      expect(vm.$el.children[0].checked).toBe(false)
-      expect(vm.$el.children[1].checked).toBe(true)
-      vm.$el.children[0].click()
-      expect(vm.$el.children[0].checked).toBe(true)
-      expect(vm.$el.children[1].checked).toBe(false)
-      expect(vm.test).toBe(1)
-    }).then(() => {
-      document.body.removeChild(vm.$el)
-    }).then(done)
-  })
-
-  it('should respect value bindings (object loose equal)', done => {
-    const vm = new Vue({
-      data: {
-        test: { a: 1 }
-      },
-      template: `
-        <div>
-          <input type="radio" :value="{ a: 1 }" v-model="test" name="test">
-          <input type="radio" :value="{ a: 2 }" v-model="test" name="test">
-        </div>
-      `
-    }).$mount()
-    document.body.appendChild(vm.$el)
-    expect(vm.$el.children[0].checked).toBe(true)
-    expect(vm.$el.children[1].checked).toBe(false)
-    vm.test = { a: 2 }
-    waitForUpdate(() => {
-      expect(vm.$el.children[0].checked).toBe(false)
-      expect(vm.$el.children[1].checked).toBe(true)
-      vm.$el.children[0].click()
-      expect(vm.$el.children[0].checked).toBe(true)
-      expect(vm.$el.children[1].checked).toBe(false)
-      expect(vm.test).toEqual({ a: 1 })
-    }).then(() => {
-      document.body.removeChild(vm.$el)
-    }).then(done)
-  })
-
-  it('multiple radios ', (done) => {
-    const spy = jasmine.createSpy()
-    const vm = new Vue({
-      data: {
-        selections: ['a', '1'],
-        radioList: [
-          {
-            name: 'questionA',
-            data: ['a', 'b', 'c']
-          },
-          {
-            name: 'questionB',
-            data: ['1', '2']
-          }
-        ]
-      },
-      watch: {
-        selections: spy
-      },
-      template:
-        '<div>' +
-          '<div v-for="(radioGroup, idx) in radioList">' +
-            '<div>' +
-              '<span v-for="(item, index) in radioGroup.data">' +
-                '<input :name="radioGroup.name" type="radio" :value="item" v-model="selections[idx]" :id="idx"/>' +
-                '<label>{{item}}</label>' +
-              '</span>' +
-            '</div>' +
-          '</div>' +
-        '</div>'
-    }).$mount()
-    document.body.appendChild(vm.$el)
-    const inputs = vm.$el.getElementsByTagName('input')
-    inputs[1].click()
-    waitForUpdate(() => {
-      expect(vm.selections).toEqual(['b', '1'])
-      expect(spy).toHaveBeenCalled()
-    }).then(done)
-  })
-
-  it('.number modifier', () => {
-    const vm = new Vue({
-      data: {
-        test: 1
-      },
-      template: `
-        <div>
-          <input type="radio" value="1" v-model="test" name="test">
-          <input type="radio" value="2" v-model.number="test" name="test">
-        </div>
-      `
-    }).$mount()
-    document.body.appendChild(vm.$el)
-    expect(vm.$el.children[0].checked).toBe(true)
-    expect(vm.$el.children[1].checked).toBe(false)
-    vm.$el.children[1].click()
-    expect(vm.$el.children[0].checked).toBe(false)
-    expect(vm.$el.children[1].checked).toBe(true)
-    expect(vm.test).toBe(2)
-  })
-
-  it('should respect different primitive type value', (done) => {
-    const vm = new Vue({
-      data: {
-        test: 1
-      },
-      template:
-        '<div>' +
-          '<input type="radio" value="" v-model="test" name="test">' +
-          '<input type="radio" value="0" v-model="test" name="test">' +
-          '<input type="radio" value="1" v-model="test" name="test">' +
-          '<input type="radio" value="false" v-model="test" name="test">' +
-          '<input type="radio" value="true" v-model="test" name="test">' +
-        '</div>'
-    }).$mount()
-    const radioboxInput = vm.$el.children
-    expect(radioboxInput[0].checked).toBe(false)
-    expect(radioboxInput[1].checked).toBe(false)
-    expect(radioboxInput[2].checked).toBe(true)
-    expect(radioboxInput[3].checked).toBe(false)
-    expect(radioboxInput[4].checked).toBe(false)
-    vm.test = 0
-    waitForUpdate(() => {
-      expect(radioboxInput[0].checked).toBe(false)
-      expect(radioboxInput[1].checked).toBe(true)
-      expect(radioboxInput[2].checked).toBe(false)
-      expect(radioboxInput[3].checked).toBe(false)
-      expect(radioboxInput[4].checked).toBe(false)
-      vm.test = ''
-    }).then(() => {
-      expect(radioboxInput[0].checked).toBe(true)
-      expect(radioboxInput[1].checked).toBe(false)
-      expect(radioboxInput[2].checked).toBe(false)
-      expect(radioboxInput[3].checked).toBe(false)
-      expect(radioboxInput[4].checked).toBe(false)
-      vm.test = false
-    }).then(() => {
-      expect(radioboxInput[0].checked).toBe(false)
-      expect(radioboxInput[1].checked).toBe(false)
-      expect(radioboxInput[2].checked).toBe(false)
-      expect(radioboxInput[3].checked).toBe(true)
-      expect(radioboxInput[4].checked).toBe(false)
-      vm.test = true
-    }).then(() => {
-      expect(radioboxInput[0].checked).toBe(false)
-      expect(radioboxInput[1].checked).toBe(false)
-      expect(radioboxInput[2].checked).toBe(false)
-      expect(radioboxInput[3].checked).toBe(false)
-      expect(radioboxInput[4].checked).toBe(true)
-    }).then(done)
-  })
-
-  // #4521
-  it('should work with click event', (done) => {
-    const vm = new Vue({
-      data: {
-        num: 1,
-        checked: 1
-      },
-      template:
-        '<div @click="add">' +
-          'click {{ num }}<input name="test" type="radio" value="1" v-model="checked"/>' +
-          '<input name="test" type="radio" value="2" v-model="checked"/>' +
-        '</div>',
-      methods: {
-        add: function () {
-          this.num++
-        }
-      }
-    }).$mount()
-    document.body.appendChild(vm.$el)
-    const radios = vm.$el.getElementsByTagName('input')
-    radios[0].click()
-    waitForUpdate(() => {
-      expect(radios[0].checked).toBe(true)
-      expect(radios[1].checked).toBe(false)
-      expect(vm.num).toBe(2)
-      radios[0].click()
-    }).then(() => {
-      expect(radios[0].checked).toBe(true)
-      expect(radios[1].checked).toBe(false)
-      expect(vm.num).toBe(3)
-      radios[1].click()
-    }).then(() => {
-      expect(radios[0].checked).toBe(false)
-      expect(radios[1].checked).toBe(true)
-      expect(vm.num).toBe(4)
-    }).then(done)
-  })
-
-  it('should get updated with model when in focus', (done) => {
-    const vm = new Vue({
-      data: {
-        a: '2'
-      },
-      template: '<input type="radio" value="1" v-model="a"/>'
-    }).$mount()
-    document.body.appendChild(vm.$el)
-    vm.$el.click()
-    waitForUpdate(() => {
-      expect(vm.$el.checked).toBe(true)
-      vm.a = 2
-    }).then(() => {
-      expect(vm.$el.checked).toBe(false)
-    }).then(done)
-  })
-})
diff --git a/1.Vue/test/unit/features/directives/model-select.spec.js b/1.Vue/test/unit/features/directives/model-select.spec.js
deleted file mode 100644
index 4fffe73..0000000
--- a/1.Vue/test/unit/features/directives/model-select.spec.js
+++ /dev/null
@@ -1,618 +0,0 @@
-import Vue from 'vue'
-import { looseEqual } from 'shared/util'
-
-// Android 4.4 Chrome 30 has the bug that a multi-select option cannot be
-// deselected by setting its "selected" prop via JavaScript.
-function hasMultiSelectBug () {
-  const s = document.createElement('select')
-  s.setAttribute('multiple', '')
-  const o = document.createElement('option')
-  s.appendChild(o)
-  o.selected = true
-  o.selected = false
-  return o.selected !== false
-}
-
-/**
- * setting <select>'s value in IE9 doesn't work
- * we have to manually loop through the options
- */
-function updateSelect (el, value) {
-  const options = el.options
-  let i = options.length
-  while (i--) {
-    if (looseEqual(getValue(options[i]), value)) {
-      options[i].selected = true
-      break
-    }
-  }
-}
-
-function getValue (option) {
-  return '_value' in option
-    ? option._value
-    : option.value || option.text
-}
-
-describe('Directive v-model select', () => {
-  it('should work', done => {
-    const vm = new Vue({
-      data: {
-        test: 'b'
-      },
-      template:
-        '<select v-model="test">' +
-          '<option>a</option>' +
-          '<option>b</option>' +
-          '<option>c</option>' +
-        '</select>'
-    }).$mount()
-    document.body.appendChild(vm.$el)
-    expect(vm.test).toBe('b')
-    expect(vm.$el.value).toBe('b')
-    expect(vm.$el.childNodes[1].selected).toBe(true)
-    vm.test = 'c'
-    waitForUpdate(function () {
-      expect(vm.$el.value).toBe('c')
-      expect(vm.$el.childNodes[2].selected).toBe(true)
-      updateSelect(vm.$el, 'a')
-      triggerEvent(vm.$el, 'change')
-      expect(vm.test).toBe('a')
-    }).then(done)
-  })
-
-  it('should work with value bindings', done => {
-    const vm = new Vue({
-      data: {
-        test: 2
-      },
-      template:
-        '<select v-model="test">' +
-          '<option value="1">a</option>' +
-          '<option :value="2">b</option>' +
-          '<option :value="3">c</option>' +
-        '</select>'
-    }).$mount()
-    document.body.appendChild(vm.$el)
-    expect(vm.$el.value).toBe('2')
-    expect(vm.$el.childNodes[1].selected).toBe(true)
-    vm.test = 3
-    waitForUpdate(function () {
-      expect(vm.$el.value).toBe('3')
-      expect(vm.$el.childNodes[2].selected).toBe(true)
-
-      updateSelect(vm.$el, '1')
-      triggerEvent(vm.$el, 'change')
-      expect(vm.test).toBe('1')
-
-      updateSelect(vm.$el, '2')
-      triggerEvent(vm.$el, 'change')
-      expect(vm.test).toBe(2)
-    }).then(done)
-  })
-
-  it('should work with value bindings (object loose equal)', done => {
-    const vm = new Vue({
-      data: {
-        test: { a: 2 }
-      },
-      template:
-        '<select v-model="test">' +
-          '<option value="1">a</option>' +
-          '<option :value="{ a: 2 }">b</option>' +
-          '<option :value="{ a: 3 }">c</option>' +
-        '</select>'
-    }).$mount()
-    document.body.appendChild(vm.$el)
-    expect(vm.$el.childNodes[1].selected).toBe(true)
-    vm.test = { a: 3 }
-    waitForUpdate(function () {
-      expect(vm.$el.childNodes[2].selected).toBe(true)
-
-      updateSelect(vm.$el, '1')
-      triggerEvent(vm.$el, 'change')
-      expect(vm.test).toBe('1')
-
-      updateSelect(vm.$el, { a: 2 })
-      triggerEvent(vm.$el, 'change')
-      expect(vm.test).toEqual({ a: 2 })
-    }).then(done)
-  })
-
-  it('should work with value bindings (Array loose equal)', done => {
-    const vm = new Vue({
-      data: {
-        test: [{ a: 2 }]
-      },
-      template:
-        '<select v-model="test">' +
-          '<option value="1">a</option>' +
-          '<option :value="[{ a: 2 }]">b</option>' +
-          '<option :value="[{ a: 3 }]">c</option>' +
-        '</select>'
-    }).$mount()
-    document.body.appendChild(vm.$el)
-    expect(vm.$el.childNodes[1].selected).toBe(true)
-    vm.test = [{ a: 3 }]
-    waitForUpdate(function () {
-      expect(vm.$el.childNodes[2].selected).toBe(true)
-
-      updateSelect(vm.$el, '1')
-      triggerEvent(vm.$el, 'change')
-      expect(vm.test).toBe('1')
-
-      updateSelect(vm.$el, [{ a: 2 }])
-      triggerEvent(vm.$el, 'change')
-      expect(vm.test).toEqual([{ a: 2 }])
-    }).then(done)
-  })
-
-  it('should work with v-for', done => {
-    const vm = new Vue({
-      data: {
-        test: 'b',
-        opts: ['a', 'b', 'c']
-      },
-      template:
-        '<select v-model="test">' +
-          '<option v-for="o in opts">{{ o }}</option>' +
-        '</select>'
-    }).$mount()
-    document.body.appendChild(vm.$el)
-    expect(vm.test).toBe('b')
-    expect(vm.$el.value).toBe('b')
-    expect(vm.$el.childNodes[1].selected).toBe(true)
-    vm.test = 'c'
-    waitForUpdate(function () {
-      expect(vm.$el.value).toBe('c')
-      expect(vm.$el.childNodes[2].selected).toBe(true)
-      updateSelect(vm.$el, 'a')
-      triggerEvent(vm.$el, 'change')
-      expect(vm.test).toBe('a')
-      // update v-for opts
-      vm.opts = ['d', 'a']
-    }).then(() => {
-      expect(vm.$el.childNodes[0].selected).toBe(false)
-      expect(vm.$el.childNodes[1].selected).toBe(true)
-    }).then(done)
-  })
-
-  it('should work with v-for & value bindings', done => {
-    const vm = new Vue({
-      data: {
-        test: 2,
-        opts: [1, 2, 3]
-      },
-      template:
-        '<select v-model="test">' +
-          '<option v-for="o in opts" :value="o">option {{ o }}</option>' +
-        '</select>'
-    }).$mount()
-    document.body.appendChild(vm.$el)
-    expect(vm.$el.value).toBe('2')
-    expect(vm.$el.childNodes[1].selected).toBe(true)
-    vm.test = 3
-    waitForUpdate(function () {
-      expect(vm.$el.value).toBe('3')
-      expect(vm.$el.childNodes[2].selected).toBe(true)
-      updateSelect(vm.$el, 1)
-      triggerEvent(vm.$el, 'change')
-      expect(vm.test).toBe(1)
-      // update v-for opts
-      vm.opts = [0, 1]
-    }).then(() => {
-      expect(vm.$el.childNodes[0].selected).toBe(false)
-      expect(vm.$el.childNodes[1].selected).toBe(true)
-    }).then(done)
-  })
-
-  it('should work with select which has no default selected options', (done) => {
-    const spy = jasmine.createSpy()
-    const vm = new Vue({
-      data: {
-        id: 4,
-        list: [1, 2, 3],
-        testChange: 5
-      },
-      template:
-        '<div>' +
-          '<select @change="test" v-model="id">' +
-            '<option v-for="item in list" :value="item">{{item}}</option>' +
-          '</select>' +
-          '{{testChange}}' +
-        '</div>',
-      methods: {
-        test: spy
-      }
-    }).$mount()
-    document.body.appendChild(vm.$el)
-    vm.testChange = 10
-    waitForUpdate(() => {
-      expect(spy.calls.count()).toBe(0)
-    }).then(done)
-  })
-
-  if (!hasMultiSelectBug()) {
-    it('multiple', done => {
-      const vm = new Vue({
-        data: {
-          test: ['b']
-        },
-        template:
-          '<select v-model="test" multiple>' +
-            '<option>a</option>' +
-            '<option>b</option>' +
-            '<option>c</option>' +
-          '</select>'
-      }).$mount()
-      const opts = vm.$el.options
-      expect(opts[0].selected).toBe(false)
-      expect(opts[1].selected).toBe(true)
-      expect(opts[2].selected).toBe(false)
-      vm.test = ['a', 'c']
-      waitForUpdate(() => {
-        expect(opts[0].selected).toBe(true)
-        expect(opts[1].selected).toBe(false)
-        expect(opts[2].selected).toBe(true)
-        opts[0].selected = false
-        opts[1].selected = true
-        triggerEvent(vm.$el, 'change')
-        expect(vm.test).toEqual(['b', 'c'])
-      }).then(done)
-    })
-
-    it('multiple + v-for', done => {
-      const vm = new Vue({
-        data: {
-          test: ['b'],
-          opts: ['a', 'b', 'c']
-        },
-        template:
-          '<select v-model="test" multiple>' +
-            '<option v-for="o in opts">{{ o }}</option>' +
-          '</select>'
-      }).$mount()
-      const opts = vm.$el.options
-      expect(opts[0].selected).toBe(false)
-      expect(opts[1].selected).toBe(true)
-      expect(opts[2].selected).toBe(false)
-      vm.test = ['a', 'c']
-      waitForUpdate(() => {
-        expect(opts[0].selected).toBe(true)
-        expect(opts[1].selected).toBe(false)
-        expect(opts[2].selected).toBe(true)
-        opts[0].selected = false
-        opts[1].selected = true
-        triggerEvent(vm.$el, 'change')
-        expect(vm.test).toEqual(['b', 'c'])
-        // update v-for opts
-        vm.opts = ['c', 'd']
-      }).then(() => {
-        expect(opts[0].selected).toBe(true)
-        expect(opts[1].selected).toBe(false)
-        expect(vm.test).toEqual(['c']) // should remove 'd' which no longer has a matching option
-      }).then(done)
-    })
-  }
-
-  it('should work with multiple binding', (done) => {
-    const spy = jasmine.createSpy()
-    const vm = new Vue({
-      data: {
-        isMultiple: true,
-        selections: ['1']
-      },
-      template:
-        '<select v-model="selections" :multiple="isMultiple">' +
-          '<option value="1">item 1</option>' +
-          '<option value="2">item 2</option>' +
-        '</select>',
-      watch: {
-        selections: spy
-      }
-    }).$mount()
-    document.body.appendChild(vm.$el)
-    vm.$el.options[1].selected = true
-    triggerEvent(vm.$el, 'change')
-    waitForUpdate(() => {
-      expect(spy).toHaveBeenCalled()
-      expect(vm.selections).toEqual(['1', '2'])
-    }).then(done)
-  })
-
-  it('should not have multiple attr with falsy values except \'\'', () => {
-    const vm = new Vue({
-      template:
-        '<div>' +
-          '<select id="undefined" :multiple="undefined"></select>' +
-          '<select id="null" :multiple="null"></select>' +
-          '<select id="false" :multiple="false"></select>' +
-          '<select id="string" :multiple="\'\'"></select>' +
-        '</div>'
-    }).$mount()
-    expect(vm.$el.querySelector('#undefined').multiple).toEqual(false)
-    expect(vm.$el.querySelector('#null').multiple).toEqual(false)
-    expect(vm.$el.querySelector('#false').multiple).toEqual(false)
-    expect(vm.$el.querySelector('#string').multiple).toEqual(true)
-  })
-
-  it('multiple with static template', () => {
-    const vm = new Vue({
-      template:
-      '<select multiple>' +
-        '<option selected>a</option>' +
-        '<option selected>b</option>' +
-        '<option selected>c</option>' +
-      '</select>'
-    }).$mount()
-    const opts = vm.$el.options
-    expect(opts[0].selected).toBe(true)
-    expect(opts[1].selected).toBe(true)
-    expect(opts[2].selected).toBe(true)
-  })
-
-  it('multiple selects', (done) => {
-    const spy = jasmine.createSpy()
-    const vm = new Vue({
-      data: {
-        selections: ['', ''],
-        selectBoxes: [
-          [
-            { value: 'foo', text: 'foo' },
-            { value: 'bar', text: 'bar' }
-          ],
-          [
-            { value: 'day', text: 'day' },
-            { value: 'night', text: 'night' }
-          ]
-        ]
-      },
-      watch: {
-        selections: spy
-      },
-      template:
-        '<div>' +
-          '<select v-for="(item, index) in selectBoxes" v-model="selections[index]">' +
-            '<option v-for="element in item" v-bind:value="element.value" v-text="element.text"></option>' +
-          '</select>' +
-          '<span ref="rs">{{selections}}</span>' +
-        '</div>'
-    }).$mount()
-    document.body.appendChild(vm.$el)
-    const selects = vm.$el.getElementsByTagName('select')
-    const select0 = selects[0]
-    select0.options[0].selected = true
-    triggerEvent(select0, 'change')
-    waitForUpdate(() => {
-      expect(spy).toHaveBeenCalled()
-      expect(vm.selections).toEqual(['foo', ''])
-    }).then(done)
-  })
-
-  it('.number modifier', () => {
-    const vm = new Vue({
-      data: {
-        test: 2
-      },
-      template:
-        '<select v-model.number="test">' +
-          '<option value="1">a</option>' +
-          '<option :value="2">b</option>' +
-          '<option :value="3">c</option>' +
-        '</select>'
-    }).$mount()
-    document.body.appendChild(vm.$el)
-    updateSelect(vm.$el, '1')
-    triggerEvent(vm.$el, 'change')
-    expect(vm.test).toBe(1)
-  })
-
-  it('should respect different primitive type value', (done) => {
-    const vm = new Vue({
-      data: {
-        test: 0
-      },
-      template:
-        '<select v-model.number="test">' +
-          '<option value="">a</option>' +
-          '<option value="0">b</option>' +
-          '<option value="1">c</option>' +
-          '<option value="false">c</option>' +
-          '<option value="true">c</option>' +
-        '</select>'
-    }).$mount()
-    const opts = vm.$el.options
-    expect(opts[0].selected).toBe(false)
-    expect(opts[1].selected).toBe(true)
-    expect(opts[2].selected).toBe(false)
-    expect(opts[3].selected).toBe(false)
-    expect(opts[4].selected).toBe(false)
-    vm.test = 1
-    waitForUpdate(() => {
-      expect(opts[0].selected).toBe(false)
-      expect(opts[1].selected).toBe(false)
-      expect(opts[2].selected).toBe(true)
-      expect(opts[3].selected).toBe(false)
-      expect(opts[4].selected).toBe(false)
-      vm.test = ''
-    }).then(() => {
-      expect(opts[0].selected).toBe(true)
-      expect(opts[1].selected).toBe(false)
-      expect(opts[2].selected).toBe(false)
-      expect(opts[3].selected).toBe(false)
-      expect(opts[4].selected).toBe(false)
-      vm.test = false
-    }).then(() => {
-      expect(opts[0].selected).toBe(false)
-      expect(opts[1].selected).toBe(false)
-      expect(opts[2].selected).toBe(false)
-      expect(opts[3].selected).toBe(true)
-      expect(opts[4].selected).toBe(false)
-      vm.test = true
-    }).then(() => {
-      expect(opts[0].selected).toBe(false)
-      expect(opts[1].selected).toBe(false)
-      expect(opts[2].selected).toBe(false)
-      expect(opts[3].selected).toBe(false)
-      expect(opts[4].selected).toBe(true)
-    }).then(done)
-  })
-
-  it('should warn multiple with non-Array value', done => {
-    new Vue({
-      data: {
-        test: 'meh'
-      },
-      template:
-        '<select v-model="test" multiple></select>'
-    }).$mount()
-    // IE warns on a setTimeout as well
-    setTimeout(() => {
-      expect('<select multiple v-model="test"> expects an Array value for its binding, but got String')
-        .toHaveBeenWarned()
-      done()
-    }, 0)
-  })
-
-  it('should work with option value that has circular reference', done => {
-    const circular = {}
-    circular.self = circular
-
-    const vm = new Vue({
-      data: {
-        test: 'b',
-        circular
-      },
-      template:
-        '<select v-model="test">' +
-          '<option :value="circular">a</option>' +
-          '<option>b</option>' +
-          '<option>c</option>' +
-        '</select>'
-    }).$mount()
-    document.body.appendChild(vm.$el)
-    expect(vm.test).toBe('b')
-    expect(vm.$el.value).toBe('b')
-    expect(vm.$el.childNodes[1].selected).toBe(true)
-    vm.test = circular
-    waitForUpdate(function () {
-      expect(vm.$el.childNodes[0].selected).toBe(true)
-    }).then(done)
-  })
-
-  // #6112
-  it('should not set non-matching value to undefined if options did not change', done => {
-    const vm = new Vue({
-      data: {
-        test: '1'
-      },
-      template:
-        '<select v-model="test">' +
-          '<option>a</option>' +
-        '</select>'
-    }).$mount()
-
-    vm.test = '2'
-    waitForUpdate(() => {
-      expect(vm.test).toBe('2')
-    }).then(done)
-  })
-
-  // #6193
-  it('should not trigger change event when matching option can be found for each value', done => {
-    const spy = jasmine.createSpy()
-    const vm = new Vue({
-      data: {
-        options: ['1']
-      },
-      computed: {
-        test: {
-          get () {
-            return '1'
-          },
-          set () {
-            spy()
-          }
-        }
-      },
-      template:
-        '<select v-model="test">' +
-          '<option :key="opt" v-for="opt in options" :value="opt">{{ opt }}</option>' +
-        '</select>'
-    }).$mount()
-
-    vm.options = ['1', '2']
-    waitForUpdate(() => {
-      expect(spy).not.toHaveBeenCalled()
-    }).then(done)
-  })
-
-  // #6903
-  describe('should correctly handle v-model when the vnodes are the same', () => {
-    function makeInstance (foo) {
-      return new Vue({
-        data: {
-          foo: foo,
-          options: ['b', 'c', 'd'],
-          value: 'c'
-        },
-        template:
-          '<div>' +
-            '<select v-if="foo" data-attr>' +
-              '<option selected>a</option>' +
-            '</select>' +
-            '<select v-else v-model="value">' +
-              '<option v-for="option in options" :value="option">{{ option }}</option>' +
-            '</select>' +
-          '</div>'
-      }).$mount()
-    }
-
-    it('register v-model', done => {
-      const vm = makeInstance(true)
-
-      expect(vm.$el.firstChild.selectedIndex).toBe(0)
-      vm.foo = false
-      waitForUpdate(() => {
-        expect(vm.$el.firstChild.selectedIndex).toBe(1)
-      }).then(done)
-    })
-
-    it('remove v-model', done => {
-      const vm = makeInstance(false)
-
-      expect(vm.$el.firstChild.selectedIndex).toBe(1)
-      vm.foo = true
-      waitForUpdate(() => {
-        expect(vm.$el.firstChild.selectedIndex).toBe(0)
-      }).then(done)
-    })
-  })
-
-  // #7928
-  it('should correctly handle option with date value', done => {
-    const vm = new Vue({
-      data: {
-        dates: [
-          new Date(1520000000000),
-          new Date(1522000000000),
-          new Date(1516000000000)
-        ],
-        selectedDate: null
-      },
-      template:
-        '<div>' +
-          '<select v-model="selectedDate">' +
-            '<option v-for="(date, i) in dates" :key="i" :value="date">' +
-              '{{date}}' +
-            '</option>' +
-          '</select>' +
-        '</div>'
-    }).$mount()
-
-    vm.selectedDate = vm.dates[2]
-    waitForUpdate(() => {
-      expect(vm.$el.firstChild.selectedIndex).toBe(2)
-    }).then(done)
-  })
-})
diff --git a/1.Vue/test/unit/features/directives/model-text.spec.js b/1.Vue/test/unit/features/directives/model-text.spec.js
deleted file mode 100644
index 7cf5167..0000000
--- a/1.Vue/test/unit/features/directives/model-text.spec.js
+++ /dev/null
@@ -1,472 +0,0 @@
-import Vue from 'vue'
-import { isIE9, isIE, isAndroid } from 'core/util/env'
-
-describe('Directive v-model text', () => {
-  it('should update value both ways', done => {
-    const vm = new Vue({
-      data: {
-        test: 'b'
-      },
-      template: '<input v-model="test">'
-    }).$mount()
-    expect(vm.$el.value).toBe('b')
-    vm.test = 'a'
-    waitForUpdate(() => {
-      expect(vm.$el.value).toBe('a')
-      vm.$el.value = 'c'
-      triggerEvent(vm.$el, 'input')
-      expect(vm.test).toBe('c')
-    }).then(done)
-  })
-
-  it('should work with space ended expression in v-model', () => {
-    const vm = new Vue({
-      data: {
-        obj: {
-          test: 'b'
-        }
-      },
-      template: '<input v-model="obj.test ">'
-    }).$mount()
-
-    triggerEvent(vm.$el, 'input')
-    expect(vm.obj['test ']).toBe(undefined)
-    expect(vm.obj.test).toBe('b')
-  })
-
-  it('.lazy modifier', () => {
-    const vm = new Vue({
-      data: {
-        test: 'b'
-      },
-      template: '<input v-model.lazy="test">'
-    }).$mount()
-    expect(vm.$el.value).toBe('b')
-    expect(vm.test).toBe('b')
-    vm.$el.value = 'c'
-    triggerEvent(vm.$el, 'input')
-    expect(vm.test).toBe('b')
-    triggerEvent(vm.$el, 'change')
-    expect(vm.test).toBe('c')
-  })
-
-  it('.number modifier', () => {
-    const vm = new Vue({
-      data: {
-        test: 1
-      },
-      template: '<input v-model.number="test">'
-    }).$mount()
-    expect(vm.test).toBe(1)
-    vm.$el.value = '2'
-    triggerEvent(vm.$el, 'input')
-    expect(vm.test).toBe(2)
-    // should let strings pass through
-    vm.$el.value = 'f'
-    triggerEvent(vm.$el, 'input')
-    expect(vm.test).toBe('f')
-  })
-
-  it('.trim modifier', () => {
-    const vm = new Vue({
-      data: {
-        test: 'hi'
-      },
-      template: '<input v-model.trim="test">'
-    }).$mount()
-    expect(vm.test).toBe('hi')
-    vm.$el.value = ' what '
-    triggerEvent(vm.$el, 'input')
-    expect(vm.test).toBe('what')
-  })
-
-  it('.number focus and typing', (done) => {
-    const vm = new Vue({
-      data: {
-        test: 0,
-        update: 0
-      },
-      template:
-        '<div>' +
-          '<input ref="input" v-model.number="test">{{ update }}' +
-          '<input ref="blur">' +
-        '</div>'
-    }).$mount()
-    document.body.appendChild(vm.$el)
-    vm.$refs.input.focus()
-    expect(vm.test).toBe(0)
-    vm.$refs.input.value = '1.0'
-    triggerEvent(vm.$refs.input, 'input')
-    expect(vm.test).toBe(1)
-    vm.update++
-    waitForUpdate(() => {
-      expect(vm.$refs.input.value).toBe('1.0')
-      vm.$refs.blur.focus()
-      vm.update++
-    }).then(() => {
-      expect(vm.$refs.input.value).toBe('1')
-    }).then(done)
-  })
-
-  it('.trim focus and typing', (done) => {
-    const vm = new Vue({
-      data: {
-        test: 'abc',
-        update: 0
-      },
-      template:
-        '<div>' +
-          '<input ref="input" v-model.trim="test" type="text">{{ update }}' +
-          '<input ref="blur"/>' +
-        '</div>'
-    }).$mount()
-    document.body.appendChild(vm.$el)
-    vm.$refs.input.focus()
-    vm.$refs.input.value = ' abc '
-    triggerEvent(vm.$refs.input, 'input')
-    expect(vm.test).toBe('abc')
-    vm.update++
-    waitForUpdate(() => {
-      expect(vm.$refs.input.value).toBe(' abc ')
-      vm.$refs.blur.focus()
-      vm.update++
-    }).then(() => {
-      expect(vm.$refs.input.value).toBe('abc')
-    }).then(done)
-  })
-
-  it('multiple inputs', (done) => {
-    const spy = jasmine.createSpy()
-    const vm = new Vue({
-      data: {
-        selections: [[1, 2, 3], [4, 5]],
-        inputList: [
-          {
-            name: 'questionA',
-            data: ['a', 'b', 'c']
-          },
-          {
-            name: 'questionB',
-            data: ['1', '2']
-          }
-        ]
-      },
-      watch: {
-        selections: spy
-      },
-      template:
-        '<div>' +
-          '<div v-for="(inputGroup, idx) in inputList">' +
-            '<div>' +
-              '<span v-for="(item, index) in inputGroup.data">' +
-                '<input v-bind:name="item" type="text" v-model.number="selections[idx][index]" v-bind:id="idx+\'-\'+index"/>' +
-                '<label>{{item}}</label>' +
-              '</span>' +
-            '</div>' +
-          '</div>' +
-          '<span ref="rs">{{selections}}</span>' +
-        '</div>'
-    }).$mount()
-    const inputs = vm.$el.getElementsByTagName('input')
-    inputs[1].value = 'test'
-    triggerEvent(inputs[1], 'input')
-    waitForUpdate(() => {
-      expect(spy).toHaveBeenCalled()
-      expect(vm.selections).toEqual([[1, 'test', 3], [4, 5]])
-    }).then(done)
-  })
-
-  if (isIE9) {
-    it('IE9 selectionchange', done => {
-      const vm = new Vue({
-        data: {
-          test: 'foo'
-        },
-        template: '<input v-model="test">'
-      }).$mount()
-      const input = vm.$el
-      input.value = 'bar'
-      document.body.appendChild(input)
-      input.focus()
-      triggerEvent(input, 'selectionchange')
-      waitForUpdate(() => {
-        expect(vm.test).toBe('bar')
-        input.value = 'a'
-        triggerEvent(input, 'selectionchange')
-        expect(vm.test).toBe('a')
-      }).then(done)
-    })
-  }
-
-  it('compositionevents', function (done) {
-    const vm = new Vue({
-      data: {
-        test: 'foo'
-      },
-      template: '<input v-model="test">'
-    }).$mount()
-    const input = vm.$el
-    triggerEvent(input, 'compositionstart')
-    input.value = 'baz'
-    // input before composition unlock should not call set
-    triggerEvent(input, 'input')
-    expect(vm.test).toBe('foo')
-    // after composition unlock it should work
-    triggerEvent(input, 'compositionend')
-    triggerEvent(input, 'input')
-    expect(vm.test).toBe('baz')
-    done()
-  })
-
-  it('warn invalid tag', () => {
-    new Vue({
-      data: {
-        test: 'foo'
-      },
-      template: '<div v-model="test"></div>'
-    }).$mount()
-    expect('<div v-model="test">: v-model is not supported on this element type').toHaveBeenWarned()
-  })
-
-  // #3468
-  it('should have higher priority than user v-on events', () => {
-    const spy = jasmine.createSpy()
-    const vm = new Vue({
-      data: {
-        a: 'a'
-      },
-      template: '<input v-model="a" @input="onInput">',
-      methods: {
-        onInput (e) {
-          spy(this.a)
-        }
-      }
-    }).$mount()
-    vm.$el.value = 'b'
-    triggerEvent(vm.$el, 'input')
-    expect(spy).toHaveBeenCalledWith('b')
-  })
-
-  it('warn binding to v-for alias', () => {
-    new Vue({
-      data: {
-        strings: ['hi']
-      },
-      template: `
-        <div>
-          <div v-for="str in strings">
-            <input v-model="str">
-          </div>
-        </div>
-      `
-    }).$mount()
-    expect('You are binding v-model directly to a v-for iteration alias').toHaveBeenWarned()
-  })
-
-  it('warn if v-model and v-bind:value conflict', () => {
-    new Vue({
-      data: {
-        test: 'foo'
-      },
-      template: '<input type="text" v-model="test" v-bind:value="test">'
-    }).$mount()
-    expect('v-bind:value="test" conflicts with v-model').toHaveBeenWarned()
-  })
-
-  it('warn if v-model and :value conflict', () => {
-    new Vue({
-      data: {
-        test: 'foo'
-      },
-      template: '<input type="text" v-model="test" :value="test">'
-    }).$mount()
-    expect(':value="test" conflicts with v-model').toHaveBeenWarned()
-  })
-
-  it('should not warn on radio, checkbox, or custom component', () => {
-    new Vue({
-      data: { test: '' },
-      components: {
-        foo: {
-          props: ['model', 'value'],
-          model: { prop: 'model', event: 'change' },
-          template: `<div/>`
-        }
-      },
-      template: `
-        <div>
-          <input type="checkbox" v-model="test" :value="test">
-          <input type="radio" v-model="test" :value="test">
-          <foo v-model="test" :value="test"/>
-        </div>
-      `
-    }).$mount()
-    expect('conflicts with v-model').not.toHaveBeenWarned()
-  })
-
-  it('should not warn on input with dynamic type binding', () => {
-    new Vue({
-      data: {
-        type: 'checkbox',
-        test: 'foo'
-      },
-      template: '<input :type="type" v-model="test" :value="test">'
-    }).$mount()
-    expect('conflicts with v-model').not.toHaveBeenWarned()
-  })
-
-  if (!isAndroid) {
-    it('does not trigger extra input events with single compositionend', () => {
-      const spy = jasmine.createSpy()
-      const vm = new Vue({
-        data: {
-          a: 'a'
-        },
-        template: '<input v-model="a" @input="onInput">',
-        methods: {
-          onInput (e) {
-            spy(e.target.value)
-          }
-        }
-      }).$mount()
-      expect(spy.calls.count()).toBe(0)
-      vm.$el.value = 'b'
-      triggerEvent(vm.$el, 'input')
-      expect(spy.calls.count()).toBe(1)
-      triggerEvent(vm.$el, 'compositionend')
-      expect(spy.calls.count()).toBe(1)
-    })
-
-    it('triggers extra input on compositionstart + end', () => {
-      const spy = jasmine.createSpy()
-      const vm = new Vue({
-        data: {
-          a: 'a'
-        },
-        template: '<input v-model="a" @input="onInput">',
-        methods: {
-          onInput (e) {
-            spy(e.target.value)
-          }
-        }
-      }).$mount()
-      expect(spy.calls.count()).toBe(0)
-      vm.$el.value = 'b'
-      triggerEvent(vm.$el, 'input')
-      expect(spy.calls.count()).toBe(1)
-      triggerEvent(vm.$el, 'compositionstart')
-      triggerEvent(vm.$el, 'compositionend')
-      expect(spy.calls.count()).toBe(2)
-    })
-
-    // #4392
-    it('should not update value with modifiers when in focus if post-conversion values are the same', done => {
-      const vm = new Vue({
-        data: {
-          a: 1,
-          foo: false
-        },
-        template: '<div>{{ foo }}<input ref="input" v-model.number="a"></div>'
-      }).$mount()
-
-      document.body.appendChild(vm.$el)
-      vm.$refs.input.focus()
-      vm.$refs.input.value = '1.000'
-      vm.foo = true
-
-      waitForUpdate(() => {
-        expect(vm.$refs.input.value).toBe('1.000')
-      }).then(done)
-    })
-
-    // #6552
-    // This was original introduced due to the microtask between DOM events issue
-    // but fixed after switching to MessageChannel.
-    it('should not block input when another input listener with modifier is used', done => {
-      const vm = new Vue({
-        data: {
-          a: 'a',
-          foo: false
-        },
-        template: `
-          <div>
-            <input ref="input" v-model="a" @input.capture="onInput">{{ a }}
-            <div v-if="foo">foo</div>
-          </div>
-        `,
-        methods: {
-          onInput (e) {
-            this.foo = true
-          }
-        }
-      }).$mount()
-
-      document.body.appendChild(vm.$el)
-      vm.$refs.input.focus()
-      vm.$refs.input.value = 'b'
-      triggerEvent(vm.$refs.input, 'input')
-
-      // not using wait for update here because there will be two update cycles
-      // one caused by onInput in the first listener
-      setTimeout(() => {
-        expect(vm.a).toBe('b')
-        expect(vm.$refs.input.value).toBe('b')
-        done()
-      }, 16)
-    })
-
-    it('should create and make reactive non-existent properties', done => {
-      const vm = new Vue({
-        data: {
-          foo: {}
-        },
-        template: '<input v-model="foo.bar">'
-      }).$mount()
-      expect(vm.$el.value).toBe('')
-
-      vm.$el.value = 'a'
-      triggerEvent(vm.$el, 'input')
-      expect(vm.foo.bar).toBe('a')
-      vm.foo.bar = 'b'
-      waitForUpdate(() => {
-        expect(vm.$el.value).toBe('b')
-        vm.foo = {}
-      }).then(() => {
-        expect(vm.$el.value).toBe('')
-      }).then(done)
-    })
-  }
-
-  if (isIE && !isIE9) {
-    // #7138
-    it('should not fire input on initial render of textarea with placeholder in IE10/11', done => {
-      const el = document.createElement('div')
-      document.body.appendChild(el)
-      const vm = new Vue({
-        el,
-        data: { foo: null },
-        template: `<textarea v-model="foo" placeholder="bar"></textarea>`
-      })
-      setTimeout(() => {
-        expect(vm.foo).toBe(null)
-        done()
-      }, 17)
-    })
-
-    // #9042
-    it('should not block the first input event when placeholder is empty', done => {
-      const el = document.createElement('div')
-      document.body.appendChild(el)
-      const vm = new Vue({
-        el,
-        data: { evtCount: 0 },
-        template: `<textarea placeholder="" @input="evtCount++"></textarea>`,
-      })
-      triggerEvent(vm.$el, 'input')
-      setTimeout(() => {
-        expect(vm.evtCount).toBe(1)
-        done()
-      }, 17)
-    })
-  }
-})
diff --git a/1.Vue/test/unit/features/directives/on.spec.js b/1.Vue/test/unit/features/directives/on.spec.js
deleted file mode 100644
index a97ddaa..0000000
--- a/1.Vue/test/unit/features/directives/on.spec.js
+++ /dev/null
@@ -1,1067 +0,0 @@
-import Vue from 'vue'
-import { supportsPassive } from 'core/util/env'
-
-describe('Directive v-on', () => {
-  let vm, spy, el
-
-  beforeEach(() => {
-    vm = null
-    spy = jasmine.createSpy()
-    el = document.createElement('div')
-    document.body.appendChild(el)
-  })
-
-  afterEach(() => {
-    if (vm) {
-      document.body.removeChild(vm.$el)
-    }
-  })
-
-  it('should bind event to a method', () => {
-    vm = new Vue({
-      el,
-      template: '<div v-on:click="foo"></div>',
-      methods: { foo: spy }
-    })
-    triggerEvent(vm.$el, 'click')
-    expect(spy.calls.count()).toBe(1)
-
-    const args = spy.calls.allArgs()
-    const event = args[0] && args[0][0] || {}
-    expect(event.type).toBe('click')
-  })
-
-  it('should bind event to a inline statement', () => {
-    vm = new Vue({
-      el,
-      template: '<div v-on:click="foo(1,2,3,$event)"></div>',
-      methods: { foo: spy }
-    })
-    triggerEvent(vm.$el, 'click')
-    expect(spy.calls.count()).toBe(1)
-
-    const args = spy.calls.allArgs()
-    const firstArgs = args[0]
-    expect(firstArgs.length).toBe(4)
-    expect(firstArgs[0]).toBe(1)
-    expect(firstArgs[1]).toBe(2)
-    expect(firstArgs[2]).toBe(3)
-    expect(firstArgs[3].type).toBe('click')
-  })
-
-  it('should support inline function expression', () => {
-    const spy = jasmine.createSpy()
-    vm = new Vue({
-      el,
-      template: `<div class="test" @click="function (e) { log(e.target.className) }"></div>`,
-      methods: {
-        log: spy
-      }
-    }).$mount()
-    triggerEvent(vm.$el, 'click')
-    expect(spy).toHaveBeenCalledWith('test')
-  })
-
-  it('should support shorthand', () => {
-    vm = new Vue({
-      el,
-      template: '<a href="#test" @click.prevent="foo"></a>',
-      methods: { foo: spy }
-    })
-    triggerEvent(vm.$el, 'click')
-    expect(spy.calls.count()).toBe(1)
-  })
-
-  it('should support stop propagation', () => {
-    vm = new Vue({
-      el,
-      template: `
-        <div @click.stop="foo"></div>
-      `,
-      methods: { foo: spy }
-    })
-    const hash = window.location.hash
-    triggerEvent(vm.$el, 'click')
-    expect(window.location.hash).toBe(hash)
-  })
-
-  it('should support prevent default', () => {
-    vm = new Vue({
-      el,
-      template: `
-        <input type="checkbox" ref="input" @click.prevent="foo">
-      `,
-      methods: {
-        foo ($event) {
-          spy($event.defaultPrevented)
-        }
-      }
-    })
-    vm.$refs.input.checked = false
-    triggerEvent(vm.$refs.input, 'click')
-    expect(spy).toHaveBeenCalledWith(true)
-  })
-
-  it('should support capture', () => {
-    const callOrder = []
-    vm = new Vue({
-      el,
-      template: `
-        <div @click.capture="foo">
-          <div @click="bar"></div>
-        </div>
-      `,
-      methods: {
-        foo () { callOrder.push(1) },
-        bar () { callOrder.push(2) }
-      }
-    })
-    triggerEvent(vm.$el.firstChild, 'click')
-    expect(callOrder.toString()).toBe('1,2')
-  })
-
-  it('should support once', () => {
-    vm = new Vue({
-      el,
-      template: `
-        <div @click.once="foo">
-        </div>
-      `,
-      methods: { foo: spy }
-    })
-    triggerEvent(vm.$el, 'click')
-    expect(spy.calls.count()).toBe(1)
-    triggerEvent(vm.$el, 'click')
-    expect(spy.calls.count()).toBe(1) // should no longer trigger
-  })
-
-  // #4655
-  it('should handle .once on multiple elements properly', () => {
-    vm = new Vue({
-      el,
-      template: `
-        <div>
-          <button ref="one" @click.once="foo">one</button>
-          <button ref="two" @click.once="foo">two</button>
-        </div>
-      `,
-      methods: { foo: spy }
-    })
-    triggerEvent(vm.$refs.one, 'click')
-    expect(spy.calls.count()).toBe(1)
-    triggerEvent(vm.$refs.one, 'click')
-    expect(spy.calls.count()).toBe(1)
-    triggerEvent(vm.$refs.two, 'click')
-    expect(spy.calls.count()).toBe(2)
-    triggerEvent(vm.$refs.one, 'click')
-    triggerEvent(vm.$refs.two, 'click')
-    expect(spy.calls.count()).toBe(2)
-  })
-
-  it('should support capture and once', () => {
-    const callOrder = []
-    vm = new Vue({
-      el,
-      template: `
-        <div @click.capture.once="foo">
-          <div @click="bar"></div>
-        </div>
-      `,
-      methods: {
-        foo () { callOrder.push(1) },
-        bar () { callOrder.push(2) }
-      }
-    })
-    triggerEvent(vm.$el.firstChild, 'click')
-    expect(callOrder.toString()).toBe('1,2')
-    triggerEvent(vm.$el.firstChild, 'click')
-    expect(callOrder.toString()).toBe('1,2,2')
-  })
-
-  // #4846
-  it('should support once and other modifiers', () => {
-    vm = new Vue({
-      el,
-      template: `<div @click.once.self="foo"><span/></div>`,
-      methods: { foo: spy }
-    })
-    triggerEvent(vm.$el.firstChild, 'click')
-    expect(spy).not.toHaveBeenCalled()
-    triggerEvent(vm.$el, 'click')
-    expect(spy).toHaveBeenCalled()
-    triggerEvent(vm.$el, 'click')
-    expect(spy.calls.count()).toBe(1)
-  })
-
-  it('should support keyCode', () => {
-    vm = new Vue({
-      el,
-      template: `<input @keyup.enter="foo">`,
-      methods: { foo: spy }
-    })
-    triggerEvent(vm.$el, 'keyup', e => {
-      e.keyCode = 13
-    })
-    expect(spy).toHaveBeenCalled()
-  })
-
-  it('should support automatic key name inference', () => {
-    vm = new Vue({
-      el,
-      template: `<input @keyup.arrow-right="foo">`,
-      methods: { foo: spy }
-    })
-    triggerEvent(vm.$el, 'keyup', e => {
-      e.key = 'ArrowRight'
-    })
-    expect(spy).toHaveBeenCalled()
-  })
-
-  // ctrl, shift, alt, meta
-  it('should support system modifers', () => {
-    vm = new Vue({
-      el,
-      template: `
-        <div>
-          <input ref="ctrl" @keyup.ctrl="foo">
-          <input ref="shift" @keyup.shift="foo">
-          <input ref="alt" @keyup.alt="foo">
-          <input ref="meta" @keyup.meta="foo">
-        </div>
-      `,
-      methods: { foo: spy }
-    })
-
-    triggerEvent(vm.$refs.ctrl, 'keyup')
-    expect(spy.calls.count()).toBe(0)
-    triggerEvent(vm.$refs.ctrl, 'keyup', e => { e.ctrlKey = true })
-    expect(spy.calls.count()).toBe(1)
-
-    triggerEvent(vm.$refs.shift, 'keyup')
-    expect(spy.calls.count()).toBe(1)
-    triggerEvent(vm.$refs.shift, 'keyup', e => { e.shiftKey = true })
-    expect(spy.calls.count()).toBe(2)
-
-    triggerEvent(vm.$refs.alt, 'keyup')
-    expect(spy.calls.count()).toBe(2)
-    triggerEvent(vm.$refs.alt, 'keyup', e => { e.altKey = true })
-    expect(spy.calls.count()).toBe(3)
-
-    triggerEvent(vm.$refs.meta, 'keyup')
-    expect(spy.calls.count()).toBe(3)
-    triggerEvent(vm.$refs.meta, 'keyup', e => { e.metaKey = true })
-    expect(spy.calls.count()).toBe(4)
-  })
-
-  it('should support exact modifier', () => {
-    vm = new Vue({
-      el,
-      template: `
-        <div>
-          <input ref="ctrl" @keyup.exact="foo">
-        </div>
-      `,
-      methods: { foo: spy }
-    })
-
-    triggerEvent(vm.$refs.ctrl, 'keyup')
-    expect(spy.calls.count()).toBe(1)
-
-    triggerEvent(vm.$refs.ctrl, 'keyup', e => {
-      e.ctrlKey = true
-    })
-    expect(spy.calls.count()).toBe(1)
-
-    // should not trigger if has other system modifiers
-    triggerEvent(vm.$refs.ctrl, 'keyup', e => {
-      e.ctrlKey = true
-      e.altKey = true
-    })
-    expect(spy.calls.count()).toBe(1)
-  })
-
-  it('should support system modifers with exact', () => {
-    vm = new Vue({
-      el,
-      template: `
-        <div>
-          <input ref="ctrl" @keyup.ctrl.exact="foo">
-        </div>
-      `,
-      methods: { foo: spy }
-    })
-
-    triggerEvent(vm.$refs.ctrl, 'keyup')
-    expect(spy.calls.count()).toBe(0)
-
-    triggerEvent(vm.$refs.ctrl, 'keyup', e => {
-      e.ctrlKey = true
-    })
-    expect(spy.calls.count()).toBe(1)
-
-    // should not trigger if has other system modifiers
-    triggerEvent(vm.$refs.ctrl, 'keyup', e => {
-      e.ctrlKey = true
-      e.altKey = true
-    })
-    expect(spy.calls.count()).toBe(1)
-  })
-
-  it('should support number keyCode', () => {
-    vm = new Vue({
-      el,
-      template: `<input @keyup.13="foo">`,
-      methods: { foo: spy }
-    })
-    triggerEvent(vm.$el, 'keyup', e => {
-      e.keyCode = 13
-    })
-    expect(spy).toHaveBeenCalled()
-  })
-
-  it('should support mouse modifier', () => {
-    const left = 0
-    const middle = 1
-    const right = 2
-    const spyLeft = jasmine.createSpy()
-    const spyMiddle = jasmine.createSpy()
-    const spyRight = jasmine.createSpy()
-
-    vm = new Vue({
-      el,
-      template: `
-        <div>
-          <div ref="left" @mousedown.left="foo">left</div>
-          <div ref="right" @mousedown.right="foo1">right</div>
-          <div ref="middle" @mousedown.middle="foo2">right</div>
-        </div>
-      `,
-      methods: {
-        foo: spyLeft,
-        foo1: spyRight,
-        foo2: spyMiddle
-      }
-    })
-
-    triggerEvent(vm.$refs.left, 'mousedown', e => { e.button = right })
-    triggerEvent(vm.$refs.left, 'mousedown', e => { e.button = middle })
-    expect(spyLeft).not.toHaveBeenCalled()
-    triggerEvent(vm.$refs.left, 'mousedown', e => { e.button = left })
-    expect(spyLeft).toHaveBeenCalled()
-
-    triggerEvent(vm.$refs.right, 'mousedown', e => { e.button = left })
-    triggerEvent(vm.$refs.right, 'mousedown', e => { e.button = middle })
-    expect(spyRight).not.toHaveBeenCalled()
-    triggerEvent(vm.$refs.right, 'mousedown', e => { e.button = right })
-    expect(spyRight).toHaveBeenCalled()
-
-    triggerEvent(vm.$refs.middle, 'mousedown', e => { e.button = left })
-    triggerEvent(vm.$refs.middle, 'mousedown', e => { e.button = right })
-    expect(spyMiddle).not.toHaveBeenCalled()
-    triggerEvent(vm.$refs.middle, 'mousedown', e => { e.button = middle })
-    expect(spyMiddle).toHaveBeenCalled()
-  })
-
-  it('should support KeyboardEvent.key for built in aliases', () => {
-    vm = new Vue({
-      el,
-      template: `
-        <div>
-          <input ref="enter" @keyup.enter="foo">
-          <input ref="space" @keyup.space="foo">
-          <input ref="esc" @keyup.esc="foo">
-          <input ref="left" @keyup.left="foo">
-          <input ref="delete" @keyup.delete="foo">
-        </div>
-      `,
-      methods: { foo: spy }
-    })
-
-    triggerEvent(vm.$refs.enter, 'keyup', e => { e.key = 'Enter' })
-    expect(spy.calls.count()).toBe(1)
-    triggerEvent(vm.$refs.space, 'keyup', e => { e.key = ' ' })
-    expect(spy.calls.count()).toBe(2)
-    triggerEvent(vm.$refs.esc, 'keyup', e => { e.key = 'Escape' })
-    expect(spy.calls.count()).toBe(3)
-    triggerEvent(vm.$refs.left, 'keyup', e => { e.key = 'ArrowLeft' })
-    expect(spy.calls.count()).toBe(4)
-    triggerEvent(vm.$refs.delete, 'keyup', e => { e.key = 'Backspace' })
-    expect(spy.calls.count()).toBe(5)
-    triggerEvent(vm.$refs.delete, 'keyup', e => { e.key = 'Delete' })
-    expect(spy.calls.count()).toBe(6)
-  })
-
-  it('should support custom keyCode', () => {
-    Vue.config.keyCodes.test = 1
-    vm = new Vue({
-      el,
-      template: `<input @keyup.test="foo">`,
-      methods: { foo: spy }
-    })
-    triggerEvent(vm.$el, 'keyup', e => {
-      e.keyCode = 1
-    })
-    expect(spy).toHaveBeenCalled()
-    Vue.config.keyCodes = Object.create(null)
-  })
-
-  it('should override build-in keyCode', () => {
-    Vue.config.keyCodes.up = [1, 87]
-    vm = new Vue({
-      el,
-      template: `<input @keyup.up="foo" @keyup.down="foo">`,
-      methods: { foo: spy }
-    })
-    triggerEvent(vm.$el, 'keyup', e => {
-      e.keyCode = 87
-    })
-    expect(spy).toHaveBeenCalled()
-    triggerEvent(vm.$el, 'keyup', e => {
-      e.keyCode = 1
-    })
-    expect(spy).toHaveBeenCalledTimes(2)
-    // should not affect build-in down keycode
-    triggerEvent(vm.$el, 'keyup', e => {
-      e.keyCode = 40
-    })
-    expect(spy).toHaveBeenCalledTimes(3)
-    Vue.config.keyCodes = Object.create(null)
-  })
-
-  it('should bind to a child component', () => {
-    vm = new Vue({
-      el,
-      template: '<bar @custom="foo"></bar>',
-      methods: { foo: spy },
-      components: {
-        bar: {
-          template: '<span>Hello</span>'
-        }
-      }
-    })
-    vm.$children[0].$emit('custom', 'foo', 'bar')
-    expect(spy).toHaveBeenCalledWith('foo', 'bar')
-  })
-
-  it('should be able to bind native events for a child component', () => {
-    vm = new Vue({
-      el,
-      template: '<bar @click.native="foo"></bar>',
-      methods: { foo: spy },
-      components: {
-        bar: {
-          template: '<span>Hello</span>'
-        }
-      }
-    })
-    vm.$children[0].$emit('click')
-    expect(spy).not.toHaveBeenCalled()
-    triggerEvent(vm.$children[0].$el, 'click')
-    expect(spy).toHaveBeenCalled()
-  })
-
-  it('.once modifier should work with child components', () => {
-    vm = new Vue({
-      el,
-      template: '<bar @custom.once="foo"></bar>',
-      methods: { foo: spy },
-      components: {
-        bar: {
-          template: '<span>Hello</span>'
-        }
-      }
-    })
-    vm.$children[0].$emit('custom')
-    expect(spy.calls.count()).toBe(1)
-    vm.$children[0].$emit('custom')
-    expect(spy.calls.count()).toBe(1) // should not be called again
-  })
-
-  it('remove listener', done => {
-    const spy2 = jasmine.createSpy('remove listener')
-    vm = new Vue({
-      el,
-      methods: { foo: spy, bar: spy2 },
-      data: {
-        ok: true
-      },
-      render (h) {
-        return this.ok
-          ? h('input', { on: { click: this.foo }})
-          : h('input', { on: { input: this.bar }})
-      }
-    })
-    triggerEvent(vm.$el, 'click')
-    expect(spy.calls.count()).toBe(1)
-    expect(spy2.calls.count()).toBe(0)
-    vm.ok = false
-    waitForUpdate(() => {
-      triggerEvent(vm.$el, 'click')
-      expect(spy.calls.count()).toBe(1) // should no longer trigger
-      triggerEvent(vm.$el, 'input')
-      expect(spy2.calls.count()).toBe(1)
-    }).then(done)
-  })
-
-  it('remove capturing listener', done => {
-    const spy2 = jasmine.createSpy('remove listener')
-    vm = new Vue({
-      el,
-      methods: { foo: spy, bar: spy2, stopped (ev) { ev.stopPropagation() } },
-      data: {
-        ok: true
-      },
-      render (h) {
-        return this.ok
-          ? h('div', { on: { '!click': this.foo }}, [h('div', { on: { click: this.stopped }})])
-          : h('div', { on: { mouseOver: this.bar }}, [h('div')])
-      }
-    })
-    triggerEvent(vm.$el.firstChild, 'click')
-    expect(spy.calls.count()).toBe(1)
-    expect(spy2.calls.count()).toBe(0)
-    vm.ok = false
-    waitForUpdate(() => {
-      triggerEvent(vm.$el.firstChild, 'click')
-      expect(spy.calls.count()).toBe(1) // should no longer trigger
-      triggerEvent(vm.$el, 'mouseOver')
-      expect(spy2.calls.count()).toBe(1)
-    }).then(done)
-  })
-
-  it('remove once listener', done => {
-    const spy2 = jasmine.createSpy('remove listener')
-    vm = new Vue({
-      el,
-      methods: { foo: spy, bar: spy2 },
-      data: {
-        ok: true
-      },
-      render (h) {
-        return this.ok
-          ? h('input', { on: { '~click': this.foo }})
-          : h('input', { on: { input: this.bar }})
-      }
-    })
-    triggerEvent(vm.$el, 'click')
-    expect(spy.calls.count()).toBe(1)
-    triggerEvent(vm.$el, 'click')
-    expect(spy.calls.count()).toBe(1) // should no longer trigger
-    expect(spy2.calls.count()).toBe(0)
-    vm.ok = false
-    waitForUpdate(() => {
-      triggerEvent(vm.$el, 'click')
-      expect(spy.calls.count()).toBe(1) // should no longer trigger
-      triggerEvent(vm.$el, 'input')
-      expect(spy2.calls.count()).toBe(1)
-    }).then(done)
-  })
-
-  it('remove capturing and once listener', done => {
-    const spy2 = jasmine.createSpy('remove listener')
-    vm = new Vue({
-      el,
-      methods: { foo: spy, bar: spy2, stopped (ev) { ev.stopPropagation() } },
-      data: {
-        ok: true
-      },
-      render (h) {
-        return this.ok
-          ? h('div', { on: { '~!click': this.foo }}, [h('div', { on: { click: this.stopped }})])
-          : h('div', { on: { mouseOver: this.bar }}, [h('div')])
-      }
-    })
-    triggerEvent(vm.$el.firstChild, 'click')
-    expect(spy.calls.count()).toBe(1)
-    triggerEvent(vm.$el.firstChild, 'click')
-    expect(spy.calls.count()).toBe(1) // should no longer trigger
-    expect(spy2.calls.count()).toBe(0)
-    vm.ok = false
-    waitForUpdate(() => {
-      triggerEvent(vm.$el.firstChild, 'click')
-      expect(spy.calls.count()).toBe(1) // should no longer trigger
-      triggerEvent(vm.$el, 'mouseOver')
-      expect(spy2.calls.count()).toBe(1)
-    }).then(done)
-  })
-
-  it('remove listener on child component', done => {
-    const spy2 = jasmine.createSpy('remove listener')
-    vm = new Vue({
-      el,
-      methods: { foo: spy, bar: spy2 },
-      data: {
-        ok: true
-      },
-      components: {
-        test: {
-          template: '<div></div>'
-        }
-      },
-      render (h) {
-        return this.ok
-          ? h('test', { on: { foo: this.foo }})
-          : h('test', { on: { bar: this.bar }})
-      }
-    })
-    vm.$children[0].$emit('foo')
-    expect(spy.calls.count()).toBe(1)
-    expect(spy2.calls.count()).toBe(0)
-    vm.ok = false
-    waitForUpdate(() => {
-      vm.$children[0].$emit('foo')
-      expect(spy.calls.count()).toBe(1) // should no longer trigger
-      vm.$children[0].$emit('bar')
-      expect(spy2.calls.count()).toBe(1)
-    }).then(done)
-  })
-
-  it('warn missing handlers', () => {
-    vm = new Vue({
-      el,
-      data: { none: null },
-      template: `<div @click="none"></div>`
-    })
-    expect(`Invalid handler for event "click": got null`).toHaveBeenWarned()
-    expect(() => {
-      triggerEvent(vm.$el, 'click')
-    }).not.toThrow()
-  })
-
-  // Github Issue #5046
-  it('should support keyboard modifier for direction keys', () => {
-    const spyLeft = jasmine.createSpy()
-    const spyRight = jasmine.createSpy()
-    const spyUp = jasmine.createSpy()
-    const spyDown = jasmine.createSpy()
-    vm = new Vue({
-      el,
-      template: `
-        <div>
-          <input ref="left" @keydown.left="foo"></input>
-          <input ref="right" @keydown.right="foo1"></input>
-          <input ref="up" @keydown.up="foo2"></input>
-          <input ref="down" @keydown.down="foo3"></input>
-        </div>
-      `,
-      methods: {
-        foo: spyLeft,
-        foo1: spyRight,
-        foo2: spyUp,
-        foo3: spyDown
-      }
-    })
-    triggerEvent(vm.$refs.left, 'keydown', e => { e.keyCode = 37 })
-    triggerEvent(vm.$refs.left, 'keydown', e => { e.keyCode = 39 })
-
-    triggerEvent(vm.$refs.right, 'keydown', e => { e.keyCode = 39 })
-    triggerEvent(vm.$refs.right, 'keydown', e => { e.keyCode = 38 })
-
-    triggerEvent(vm.$refs.up, 'keydown', e => { e.keyCode = 38 })
-    triggerEvent(vm.$refs.up, 'keydown', e => { e.keyCode = 37 })
-
-    triggerEvent(vm.$refs.down, 'keydown', e => { e.keyCode = 40 })
-    triggerEvent(vm.$refs.down, 'keydown', e => { e.keyCode = 39 })
-
-    expect(spyLeft.calls.count()).toBe(1)
-    expect(spyRight.calls.count()).toBe(1)
-    expect(spyUp.calls.count()).toBe(1)
-    expect(spyDown.calls.count()).toBe(1)
-  })
-
-  // This test case should only run when the test browser supports passive.
-  if (supportsPassive) {
-    it('should support passive', () => {
-      vm = new Vue({
-        el,
-        template: `
-          <div>
-            <input type="checkbox" ref="normal" @click="foo"/>
-            <input type="checkbox" ref="passive" @click.passive="foo"/>
-            <input type="checkbox" ref="exclusive" @click.prevent.passive/>
-          </div>
-        `,
-        methods: {
-          foo (e) {
-            e.preventDefault()
-          }
-        }
-      })
-
-      vm.$refs.normal.checked = false
-      vm.$refs.passive.checked = false
-      vm.$refs.exclusive.checked = false
-      vm.$refs.normal.click()
-      vm.$refs.passive.click()
-      vm.$refs.exclusive.click()
-      expect(vm.$refs.normal.checked).toBe(false)
-      expect(vm.$refs.passive.checked).toBe(true)
-      expect(vm.$refs.exclusive.checked).toBe(true)
-      expect('passive and prevent can\'t be used together. Passive handler can\'t prevent default event.').toHaveBeenWarned()
-    })
-  }
-
-  // GitHub Issues #5146
-  it('should only prevent when match keycode', () => {
-    let prevented = false
-    vm = new Vue({
-      el,
-      template: `
-        <input ref="input" @keydown.enter.prevent="foo">
-      `,
-      methods: {
-        foo ($event) {
-          prevented = $event.defaultPrevented
-        }
-      }
-    })
-
-    triggerEvent(vm.$refs.input, 'keydown', e => { e.keyCode = 32 })
-    expect(prevented).toBe(false)
-    triggerEvent(vm.$refs.input, 'keydown', e => { e.keyCode = 13 })
-    expect(prevented).toBe(true)
-  })
-
-  it('should transform click.right to contextmenu', () => {
-    const spy = jasmine.createSpy('click.right')
-    const vm = new Vue({
-      template: `<div @click.right="foo"></div>`,
-      methods: { foo: spy }
-    }).$mount()
-
-    triggerEvent(vm.$el, 'contextmenu')
-    expect(spy).toHaveBeenCalled()
-  })
-
-  it('should transform click.middle to mouseup', () => {
-    const spy = jasmine.createSpy('click.middle')
-    vm = new Vue({
-      el,
-      template: `<div @click.middle="foo"></div>`,
-      methods: { foo: spy }
-    })
-    triggerEvent(vm.$el, 'mouseup', e => { e.button = 0 })
-    expect(spy).not.toHaveBeenCalled()
-    triggerEvent(vm.$el, 'mouseup', e => { e.button = 1 })
-    expect(spy).toHaveBeenCalled()
-  })
-
-  it('object syntax (no argument)', () => {
-    const click = jasmine.createSpy('click')
-    const mouseup = jasmine.createSpy('mouseup')
-    vm = new Vue({
-      el,
-      template: `<button v-on="listeners">foo</button>`,
-      created () {
-        this.listeners = {
-          click,
-          mouseup
-        }
-      }
-    })
-
-    triggerEvent(vm.$el, 'click')
-    expect(click.calls.count()).toBe(1)
-    expect(mouseup.calls.count()).toBe(0)
-
-    triggerEvent(vm.$el, 'mouseup')
-    expect(click.calls.count()).toBe(1)
-    expect(mouseup.calls.count()).toBe(1)
-  })
-
-  it('object syntax (no argument, mixed with normal listeners)', () => {
-    const click1 = jasmine.createSpy('click1')
-    const click2 = jasmine.createSpy('click2')
-    const mouseup = jasmine.createSpy('mouseup')
-    vm = new Vue({
-      el,
-      template: `<button v-on="listeners" @click="click2">foo</button>`,
-      created () {
-        this.listeners = {
-          click: click1,
-          mouseup
-        }
-      },
-      methods: {
-        click2
-      }
-    })
-
-    triggerEvent(vm.$el, 'click')
-    expect(click1.calls.count()).toBe(1)
-    expect(click2.calls.count()).toBe(1)
-    expect(mouseup.calls.count()).toBe(0)
-
-    triggerEvent(vm.$el, 'mouseup')
-    expect(click1.calls.count()).toBe(1)
-    expect(click2.calls.count()).toBe(1)
-    expect(mouseup.calls.count()).toBe(1)
-  })
-
-  it('object syntax (usage in HOC, mixed with native listeners)', () => {
-    const click = jasmine.createSpy('click')
-    const mouseup = jasmine.createSpy('mouseup')
-    const mousedown = jasmine.createSpy('mousedown')
-
-    vm = new Vue({
-      el,
-      template: `
-        <foo-button
-          @click="click"
-          @mousedown="mousedown"
-          @mouseup.native="mouseup">
-        </foo-button>
-      `,
-      methods: {
-        click,
-        mouseup,
-        mousedown
-      },
-      components: {
-        fooButton: {
-          template: `
-            <button v-on="$listeners"></button>
-          `
-        }
-      }
-    })
-
-    triggerEvent(vm.$el, 'click')
-    expect(click.calls.count()).toBe(1)
-    expect(mouseup.calls.count()).toBe(0)
-    expect(mousedown.calls.count()).toBe(0)
-
-    triggerEvent(vm.$el, 'mouseup')
-    expect(click.calls.count()).toBe(1)
-    expect(mouseup.calls.count()).toBe(1)
-    expect(mousedown.calls.count()).toBe(0)
-
-    triggerEvent(vm.$el, 'mousedown')
-    expect(click.calls.count()).toBe(1)
-    expect(mouseup.calls.count()).toBe(1)
-    expect(mousedown.calls.count()).toBe(1)
-  })
-
-  // #6805 (v-on="object" bind order problem)
-  it('object syntax (no argument): should fire after high-priority listeners', done => {
-    const MyCheckbox = {
-      template: '<input type="checkbox" v-model="model" v-on="$listeners">',
-      props: {
-        value: false
-      },
-      computed: {
-        model: {
-          get () {
-            return this.value
-          },
-          set (val) {
-            this.$emit('input', val)
-          }
-        }
-      }
-    }
-
-    vm = new Vue({
-      el,
-      template: `
-        <div>
-          <my-checkbox v-model="check" @change="change"></my-checkbox>
-        </div>
-      `,
-      components: { MyCheckbox },
-      data: {
-        check: false
-      },
-      methods: {
-        change () {
-          expect(this.check).toBe(true)
-          done()
-        }
-      }
-    })
-
-    vm.$el.querySelector('input').click()
-  })
-
-  it('warn object syntax with modifier', () => {
-    new Vue({
-      template: `<button v-on.self="{}"></button>`
-    }).$mount()
-    expect(`v-on without argument does not support modifiers`).toHaveBeenWarned()
-  })
-
-  it('warn object syntax with non-object value', () => {
-    new Vue({
-      template: `<button v-on="123"></button>`
-    }).$mount()
-    expect(`v-on without argument expects an Object value`).toHaveBeenWarned()
-  })
-
-  it('should correctly remove once listener', done => {
-    const vm = new Vue({
-      template: `
-        <div>
-          <span v-if="ok" @click.once="foo">
-            a
-          </span>
-          <span v-else a="a">
-            b
-          </span>
-        </div>
-      `,
-      data: {
-        ok: true
-      },
-      methods: {
-        foo: spy
-      }
-    }).$mount()
-
-    vm.ok = false
-    waitForUpdate(() => {
-      triggerEvent(vm.$el.childNodes[0], 'click')
-      expect(spy.calls.count()).toBe(0)
-    }).then(done)
-  })
-
-  // #7628
-  it('handler should return the return value of inline function invocation', () => {
-    let value
-    new Vue({
-      template: `<test @foo="bar()"></test>`,
-      methods: {
-        bar() {
-          return 1
-        }
-      },
-      components: {
-        test: {
-          created() {
-            value = this.$listeners.foo()
-          },
-          render(h) {
-            return h('div')
-          }
-        }
-      }
-    }).$mount()
-    expect(value).toBe(1)
-  })
-
-  describe('dynamic arguments', () => {
-    it('basic', done => {
-      const spy = jasmine.createSpy()
-      const vm = new Vue({
-        template: `<div v-on:[key]="spy"></div>`,
-        data: {
-          key: 'click'
-        },
-        methods: {
-          spy
-        }
-      }).$mount()
-      triggerEvent(vm.$el, 'click')
-      expect(spy.calls.count()).toBe(1)
-      vm.key = 'mouseup'
-      waitForUpdate(() => {
-        triggerEvent(vm.$el, 'click')
-        expect(spy.calls.count()).toBe(1)
-        triggerEvent(vm.$el, 'mouseup')
-        expect(spy.calls.count()).toBe(2)
-        // explicit null value
-        vm.key = null
-      }).then(() => {
-        triggerEvent(vm.$el, 'click')
-        expect(spy.calls.count()).toBe(2)
-        triggerEvent(vm.$el, 'mouseup')
-        expect(spy.calls.count()).toBe(2)
-      }).then(done)
-    })
-
-    it('shorthand', done => {
-      const spy = jasmine.createSpy()
-      const vm = new Vue({
-        template: `<div @[key]="spy"></div>`,
-        data: {
-          key: 'click'
-        },
-        methods: {
-          spy
-        }
-      }).$mount()
-      triggerEvent(vm.$el, 'click')
-      expect(spy.calls.count()).toBe(1)
-      vm.key = 'mouseup'
-      waitForUpdate(() => {
-        triggerEvent(vm.$el, 'click')
-        expect(spy.calls.count()).toBe(1)
-        triggerEvent(vm.$el, 'mouseup')
-        expect(spy.calls.count()).toBe(2)
-      }).then(done)
-    })
-
-    it('with .middle modifier', () => {
-      const spy = jasmine.createSpy()
-      const vm = new Vue({
-        template: `<div @[key].middle="spy"></div>`,
-        data: {
-          key: 'click'
-        },
-        methods: {
-          spy
-        }
-      }).$mount()
-      triggerEvent(vm.$el, 'mouseup', e => { e.button = 0 })
-      expect(spy).not.toHaveBeenCalled()
-      triggerEvent(vm.$el, 'mouseup', e => { e.button = 1 })
-      expect(spy).toHaveBeenCalled()
-    })
-
-    it('with .right modifier', () => {
-      const spy = jasmine.createSpy()
-      const vm = new Vue({
-        template: `<div @[key].right="spy"></div>`,
-        data: {
-          key: 'click'
-        },
-        methods: {
-          spy
-        }
-      }).$mount()
-      triggerEvent(vm.$el, 'contextmenu')
-      expect(spy).toHaveBeenCalled()
-    })
-
-    it('with .capture modifier', () => {
-      const callOrder = []
-      const vm = new Vue({
-        template: `
-          <div @[key].capture="foo">
-            <div @[key]="bar"></div>
-          </div>
-        `,
-        data: {
-          key: 'click'
-        },
-        methods: {
-          foo () { callOrder.push(1) },
-          bar () { callOrder.push(2) }
-        }
-      }).$mount()
-      triggerEvent(vm.$el.firstChild, 'click')
-      expect(callOrder.toString()).toBe('1,2')
-    })
-
-    it('with .once modifier', () => {
-      const vm = new Vue({
-        template: `<div @[key].once="foo"></div>`,
-        data: { key: 'click' },
-        methods: { foo: spy }
-      }).$mount()
-      triggerEvent(vm.$el, 'click')
-      expect(spy.calls.count()).toBe(1)
-      triggerEvent(vm.$el, 'click')
-      expect(spy.calls.count()).toBe(1) // should no longer trigger
-    })
-  })
-})
diff --git a/1.Vue/test/unit/features/directives/once.spec.js b/1.Vue/test/unit/features/directives/once.spec.js
deleted file mode 100644
index eca8be0..0000000
--- a/1.Vue/test/unit/features/directives/once.spec.js
+++ /dev/null
@@ -1,364 +0,0 @@
-import Vue from 'vue'
-
-describe('Directive v-once', () => {
-  it('should not rerender component', done => {
-    const vm = new Vue({
-      template: '<div v-once>{{ a }}</div>',
-      data: { a: 'hello' }
-    }).$mount()
-    expect(vm.$el.innerHTML).toBe('hello')
-    vm.a = 'world'
-    waitForUpdate(() => {
-      expect(vm.$el.innerHTML).toBe('hello')
-    }).then(done)
-  })
-
-  it('should not rerender self and child component', done => {
-    const vm = new Vue({
-      template: `
-        <div v-once>
-          <span>{{ a }}</span>
-          <item :b="a"></item>
-        </div>`,
-      data: { a: 'hello' },
-      components: {
-        item: {
-          template: '<div>{{ b }}</div>',
-          props: ['b']
-        }
-      }
-    }).$mount()
-    expect(vm.$children.length).toBe(1)
-    expect(vm.$el.innerHTML)
-      .toBe('<span>hello</span> <div>hello</div>')
-    vm.a = 'world'
-    waitForUpdate(() => {
-      expect(vm.$el.innerHTML)
-        .toBe('<span>hello</span> <div>hello</div>')
-    }).then(done)
-  })
-
-  it('should rerender parent but not self', done => {
-    const vm = new Vue({
-      template: `
-        <div>
-          <span>{{ a }}</span>
-          <item v-once :b="a"></item>
-        </div>`,
-      data: { a: 'hello' },
-      components: {
-        item: {
-          template: '<div>{{ b }}</div>',
-          props: ['b']
-        }
-      }
-    }).$mount()
-    expect(vm.$children.length).toBe(1)
-    expect(vm.$el.innerHTML)
-      .toBe('<span>hello</span> <div>hello</div>')
-    vm.a = 'world'
-    waitForUpdate(() => {
-      expect(vm.$el.innerHTML)
-        .toBe('<span>world</span> <div>hello</div>')
-    }).then(done)
-  })
-
-  it('should not rerender static sub nodes', done => {
-    const vm = new Vue({
-      template: `
-        <div>
-          <span v-once>{{ a }}</span>
-          <item :b="a"></item>
-          <span>{{ suffix }}</span>
-        </div>`,
-      data: {
-        a: 'hello',
-        suffix: '?'
-      },
-      components: {
-        item: {
-          template: '<div>{{ b }}</div>',
-          props: ['b']
-        }
-      }
-    }).$mount()
-    expect(vm.$el.innerHTML)
-      .toBe('<span>hello</span> <div>hello</div> <span>?</span>')
-    vm.a = 'world'
-    waitForUpdate(() => {
-      expect(vm.$el.innerHTML)
-        .toBe('<span>hello</span> <div>world</div> <span>?</span>')
-      vm.suffix = '!'
-    }).then(() => {
-      expect(vm.$el.innerHTML)
-        .toBe('<span>hello</span> <div>world</div> <span>!</span>')
-    }).then(done)
-  })
-
-  it('should work with v-if', done => {
-    const vm = new Vue({
-      data: {
-        tester: true,
-        yes: 'y',
-        no: 'n'
-      },
-      template: `
-        <div>
-          <div v-if="tester">{{ yes }}</div>
-          <div v-else>{{ no }}</div>
-          <div v-if="tester" v-once>{{ yes }}</div>
-          <div v-else>{{ no }}</div>
-          <div v-if="tester">{{ yes }}</div>
-          <div v-else v-once>{{ no }}</div>
-          <div v-if="tester" v-once>{{ yes }}</div>
-          <div v-else v-once>{{ no }}</div>
-        </div>
-      `
-    }).$mount()
-    expectTextContent(vm, 'yyyy')
-    vm.yes = 'yes'
-    waitForUpdate(() => {
-      expectTextContent(vm, 'yesyyesy')
-      vm.tester = false
-    }).then(() => {
-      expectTextContent(vm, 'nnnn')
-      vm.no = 'no'
-    }).then(() => {
-      expectTextContent(vm, 'nononn')
-    }).then(done)
-  })
-
-  it('should work with v-for', done => {
-    const vm = new Vue({
-      data: {
-        list: [1, 2, 3]
-      },
-      template: `<div><div v-for="i in list" v-once>{{i}}</div></div>`
-    }).$mount()
-    expect(vm.$el.textContent).toBe('123')
-    vm.list.reverse()
-    waitForUpdate(() => {
-      expect(vm.$el.textContent).toBe('123')
-    }).then(done)
-  })
-
-  it('should work inside v-for', done => {
-    const vm = new Vue({
-      data: {
-        list: [
-          { id: 0, text: 'a' },
-          { id: 1, text: 'b' },
-          { id: 2, text: 'c' }
-        ]
-      },
-      template: `
-        <div>
-          <div v-for="i in list" :key="i.id">
-            <div>
-              <span v-once>{{ i.text }}</span><span>{{ i.text }}</span>
-            </div>
-          </div>
-        </div>
-      `
-    }).$mount()
-
-    expect(vm.$el.textContent).toBe('aabbcc')
-
-    vm.list[0].text = 'd'
-    waitForUpdate(() => {
-      expect(vm.$el.textContent).toBe('adbbcc')
-      vm.list[1].text = 'e'
-    }).then(() => {
-      expect(vm.$el.textContent).toBe('adbecc')
-      vm.list.reverse()
-    }).then(() => {
-      expect(vm.$el.textContent).toBe('ccbead')
-    }).then(done)
-  })
-
-  it('should work inside v-for with v-if', done => {
-    const vm = new Vue({
-      data: {
-        list: [
-          { id: 0, text: 'a', tester: true, truthy: 'y' }
-        ]
-      },
-      template: `
-        <div>
-          <div v-for="i in list" :key="i.id">
-              <span v-if="i.tester" v-once>{{ i.truthy }}</span>
-              <span v-else v-once>{{ i.text }}</span>
-              <span v-if="i.tester" v-once>{{ i.truthy }}</span>
-              <span v-else>{{ i.text }}</span>
-              <span v-if="i.tester">{{ i.truthy }}</span>
-              <span v-else v-once>{{ i.text }}</span>
-              <span v-if="i.tester">{{ i.truthy }}</span>
-              <span v-else>{{ i.text }}</span>
-          </div>
-        </div>
-      `
-    }).$mount()
-
-    expectTextContent(vm, 'yyyy')
-
-    vm.list[0].truthy = 'yy'
-    waitForUpdate(() => {
-      expectTextContent(vm, 'yyyyyy')
-      vm.list[0].tester = false
-    }).then(() => {
-      expectTextContent(vm, 'aaaa')
-      vm.list[0].text = 'nn'
-    }).then(() => {
-      expectTextContent(vm, 'annann')
-    }).then(done)
-  })
-
-  it('should work inside v-for with nested v-else', done => {
-    const vm = new Vue({
-      data: {
-        list: [{ id: 0, text: 'a', tester: true, truthy: 'y' }]
-      },
-      template: `
-        <div v-if="0"></div>
-        <div v-else>
-          <div v-for="i in list" :key="i.id">
-            <span v-if="i.tester" v-once>{{ i.truthy }}</span>
-            <span v-else v-once>{{ i.text }}</span>
-          </div>
-        </div>
-      `
-    }).$mount()
-
-    expectTextContent(vm, 'y')
-    vm.list[0].truthy = 'yy'
-    waitForUpdate(() => {
-      expectTextContent(vm, 'y')
-      vm.list[0].tester = false
-    }).then(() => {
-      expectTextContent(vm, 'a')
-      vm.list[0].text = 'nn'
-    }).then(() => {
-      expectTextContent(vm, 'a')
-    }).then(done)
-  })
-
-  it('should work inside v-for with nested v-else-if and v-else', done => {
-    const vm = new Vue({
-      data: {
-        tester: false,
-        list: [{ id: 0, text: 'a', tester: true, truthy: 'y' }]
-      },
-      template: `
-        <div v-if="0"></div>
-        <div v-else-if="tester">
-          <div v-for="i in list" :key="i.id">
-            <span v-if="i.tester" v-once>{{ i.truthy }}</span>
-            <span v-else-if="tester" v-once>{{ i.text }}elseif</span>
-            <span v-else v-once>{{ i.text }}</span>
-          </div>
-        </div>
-        <div v-else>
-          <div v-for="i in list" :key="i.id">
-            <span v-if="i.tester" v-once>{{ i.truthy }}</span>
-            <span v-else-if="tester">{{ i.text }}elseif</span>
-            <span v-else v-once>{{ i.text }}</span>
-          </div>
-        </div>
-      `
-    }).$mount()
-
-    expectTextContent(vm, 'y')
-    vm.list[0].truthy = 'yy'
-    waitForUpdate(() => {
-      expectTextContent(vm, 'y')
-      vm.list[0].tester = false
-    }).then(() => {
-      expectTextContent(vm, 'a')
-      vm.list[0].text = 'nn'
-    }).then(() => {
-      expectTextContent(vm, 'a')
-      vm.tester = true
-    }).then(() => {
-      expectTextContent(vm, 'nnelseif')
-      vm.list[0].text = 'xx'
-    }).then(() => {
-      expectTextContent(vm, 'nnelseif')
-      vm.list[0].tester = true
-    }).then(() => {
-      expectTextContent(vm, 'yy')
-      vm.list[0].truthy = 'nn'
-    }).then(() => {
-      expectTextContent(vm, 'yy')
-    }).then(done)
-  })
-
-  it('should warn inside non-keyed v-for', () => {
-    const vm = new Vue({
-      data: {
-        list: [
-          { id: 0, text: 'a' },
-          { id: 1, text: 'b' },
-          { id: 2, text: 'c' }
-        ]
-      },
-      template: `
-        <div>
-          <div v-for="i in list">
-            <span v-once>{{ i.text }}</span><span>{{ i.text }}</span>
-          </div>
-        </div>
-      `
-    }).$mount()
-
-    expect(vm.$el.textContent).toBe('aabbcc')
-    expect(`v-once can only be used inside v-for that is keyed.`).toHaveBeenWarned()
-  })
-
-  // #4288
-  it('should inherit child reference for v-once', done => {
-    const vm = new Vue({
-      template: `<div>{{a}}<test v-if="ok" v-once></test></div>`,
-      data: {
-        a: 0,
-        ok: true
-      },
-      components: {
-        test: {
-          template: '<div>foo</div>'
-        }
-      }
-    }).$mount()
-    vm.a++ // first update to force a patch
-    waitForUpdate(() => {
-      expect(vm.$el.textContent).toBe('1foo')
-    }).then(() => {
-      vm.ok = false // teardown component with v-once
-    }).then(done) // should not throw
-  })
-
-  // #6826
-  it('should render different component instances properly', done => {
-    const vm = new Vue({
-      components: {
-        foo: {
-          props: ['name'],
-          template: '<div v-once>{{ name }}</div>'
-        }
-      },
-      template: `
-        <div>
-          <foo name="a" v-once></foo>
-          <foo name="b" v-once></foo>
-        </div>
-      `
-    }).$mount()
-    waitForUpdate(() => {
-      expect(vm.$el.children[0].innerHTML).toBe('a')
-      expect(vm.$el.children[1].innerHTML).toBe('b')
-    }).then(done)
-  })
-})
-
-function expectTextContent (vm, text) {
-  expect(vm.$el.textContent.replace(/\s+/g, '')).toBe(text)
-}
diff --git a/1.Vue/test/unit/features/directives/pre.spec.js b/1.Vue/test/unit/features/directives/pre.spec.js
deleted file mode 100644
index ed48bf0..0000000
--- a/1.Vue/test/unit/features/directives/pre.spec.js
+++ /dev/null
@@ -1,45 +0,0 @@
-import Vue from 'vue'
-
-describe('Directive v-pre', function () {
-  it('should not compile inner content', function () {
-    const vm = new Vue({
-      template: `<div>
-        <div v-pre>{{ a }}</div>
-        <div>{{ a }}</div>
-        <div v-pre>
-          <component is="div"></component>
-        </div>
-      </div>`,
-      data: {
-        a: 123
-      }
-    })
-    vm.$mount()
-    expect(vm.$el.firstChild.textContent).toBe('{{ a }}')
-    expect(vm.$el.children[1].textContent).toBe('123')
-    expect(vm.$el.lastChild.innerHTML).toBe('<component is="div"></component>')
-  })
-
-  it('should not compile on root node', function () {
-    const vm = new Vue({
-      template: '<div v-pre>{{ a }}</div>',
-      replace: true,
-      data: {
-        a: 123
-      }
-    })
-    vm.$mount()
-    expect(vm.$el.firstChild.textContent).toBe('{{ a }}')
-  })
-
-  // #8286
-  it('should not compile custom component tags', function () {
-    Vue.component('vtest', { template: ` <div>Hello World</div>` })
-    const vm = new Vue({
-      template: '<div v-pre><vtest></vtest></div>',
-      replace: true
-    })
-    vm.$mount()
-    expect(vm.$el.firstChild.tagName).toBe('VTEST')
-  })
-})
diff --git a/1.Vue/test/unit/features/directives/show.spec.js b/1.Vue/test/unit/features/directives/show.spec.js
deleted file mode 100644
index dd50957..0000000
--- a/1.Vue/test/unit/features/directives/show.spec.js
+++ /dev/null
@@ -1,84 +0,0 @@
-import Vue from 'vue'
-
-describe('Directive v-show', () => {
-  it('should check show value is truthy', () => {
-    const vm = new Vue({
-      template: '<div><span v-show="foo">hello</span></div>',
-      data: { foo: true }
-    }).$mount()
-    expect(vm.$el.firstChild.style.display).toBe('')
-  })
-
-  it('should check show value is falsy', () => {
-    const vm = new Vue({
-      template: '<div><span v-show="foo">hello</span></div>',
-      data: { foo: false }
-    }).$mount()
-    expect(vm.$el.firstChild.style.display).toBe('none')
-  })
-
-  it('should update show value changed', done => {
-    const vm = new Vue({
-      template: '<div><span v-show="foo">hello</span></div>',
-      data: { foo: true }
-    }).$mount()
-    expect(vm.$el.firstChild.style.display).toBe('')
-    vm.foo = false
-    waitForUpdate(() => {
-      expect(vm.$el.firstChild.style.display).toBe('none')
-      vm.foo = {}
-    }).then(() => {
-      expect(vm.$el.firstChild.style.display).toBe('')
-      vm.foo = 0
-    }).then(() => {
-      expect(vm.$el.firstChild.style.display).toBe('none')
-      vm.foo = []
-    }).then(() => {
-      expect(vm.$el.firstChild.style.display).toBe('')
-      vm.foo = null
-    }).then(() => {
-      expect(vm.$el.firstChild.style.display).toBe('none')
-      vm.foo = '0'
-    }).then(() => {
-      expect(vm.$el.firstChild.style.display).toBe('')
-      vm.foo = undefined
-    }).then(() => {
-      expect(vm.$el.firstChild.style.display).toBe('none')
-      vm.foo = 1
-    }).then(() => {
-      expect(vm.$el.firstChild.style.display).toBe('')
-    }).then(done)
-  })
-
-  it('should respect display value in style attribute', done => {
-    const vm = new Vue({
-      template: '<div><span v-show="foo" style="display:block">hello</span></div>',
-      data: { foo: true }
-    }).$mount()
-    expect(vm.$el.firstChild.style.display).toBe('block')
-    vm.foo = false
-    waitForUpdate(() => {
-      expect(vm.$el.firstChild.style.display).toBe('none')
-      vm.foo = true
-    }).then(() => {
-      expect(vm.$el.firstChild.style.display).toBe('block')
-    }).then(done)
-  })
-
-  it('should support unbind when reused', done => {
-    const vm = new Vue({
-      template:
-        '<div v-if="tester"><span v-show="false"></span></div>' +
-        '<div v-else><span @click="tester=!tester">show</span></div>',
-      data: { tester: true }
-    }).$mount()
-    expect(vm.$el.firstChild.style.display).toBe('none')
-    vm.tester = false
-    waitForUpdate(() => {
-      expect(vm.$el.firstChild.style.display).toBe('')
-      vm.tester = true
-    }).then(() => {
-      expect(vm.$el.firstChild.style.display).toBe('none')
-    }).then(done)
-  })
-})
diff --git a/1.Vue/test/unit/features/directives/static-style-parser.spec.js b/1.Vue/test/unit/features/directives/static-style-parser.spec.js
deleted file mode 100644
index 13dd675..0000000
--- a/1.Vue/test/unit/features/directives/static-style-parser.spec.js
+++ /dev/null
@@ -1,41 +0,0 @@
-import { parseStyleText } from 'web/util/style'
-const base64ImgUrl = 'url("data:image/webp;base64,UklGRkoAAABXRUJQVlA4WAoAAAAQAAAAAAAAAAAAQUxQSAwAAAARBxAR/Q9ERP8DAABWUDggGAAAABQBAJ0BKgEAAQAAAP4AAA3AAP7mtQAAAA==")'
-const logoUrl = 'url(https://vuejs.org/images/logo.png)'
-
-it('should parse normal static style', () => {
-  const staticStyle = `font-size: 12px;background: ${logoUrl};color:red`
-  const res = parseStyleText(staticStyle)
-  expect(res.background).toBe(logoUrl)
-  expect(res.color).toBe('red')
-  expect(res['font-size']).toBe('12px')
-})
-
-it('should parse base64 background', () => {
-  const staticStyle = `background: ${base64ImgUrl}`
-  const res = parseStyleText(staticStyle)
-  expect(res.background).toBe(base64ImgUrl)
-})
-
-it('should parse multiple background images ', () => {
-  let staticStyle = `background: ${logoUrl}, ${logoUrl};`
-  let res = parseStyleText(staticStyle)
-  expect(res.background).toBe(`${logoUrl}, ${logoUrl}`)
-
-  staticStyle = `background: ${base64ImgUrl}, ${base64ImgUrl}`
-  res = parseStyleText(staticStyle)
-  expect(res.background).toBe(`${base64ImgUrl}, ${base64ImgUrl}`)
-})
-
-it('should parse other images ', () => {
-  let staticStyle = `shape-outside: ${logoUrl}`
-  let res = parseStyleText(staticStyle)
-  expect(res['shape-outside']).toBe(logoUrl)
-
-  staticStyle = `list-style-image: ${logoUrl}`
-  res = parseStyleText(staticStyle)
-  expect(res['list-style-image']).toBe(logoUrl)
-
-  staticStyle = `border-image: ${logoUrl} 30 30 repeat`
-  res = parseStyleText(staticStyle)
-  expect(res['border-image']).toBe(`${logoUrl} 30 30 repeat`)
-})
diff --git a/1.Vue/test/unit/features/directives/style.spec.js b/1.Vue/test/unit/features/directives/style.spec.js
deleted file mode 100644
index d611ca4..0000000
--- a/1.Vue/test/unit/features/directives/style.spec.js
+++ /dev/null
@@ -1,388 +0,0 @@
-import Vue from 'vue'
-
-function checkPrefixedProp (prop) {
-  const el = document.createElement('div')
-  const upper = prop.charAt(0).toUpperCase() + prop.slice(1)
-  if (!(prop in el.style)) {
-    const prefixes = ['Webkit', 'Moz', 'ms']
-    let i = prefixes.length
-    while (i--) {
-      if ((prefixes[i] + upper) in el.style) {
-        prop = prefixes[i] + upper
-      }
-    }
-  }
-  return prop
-}
-
-describe('Directive v-bind:style', () => {
-  let vm
-
-  beforeEach(() => {
-    vm = new Vue({
-      template: '<div :style="styles"></div>',
-      data () {
-        return {
-          styles: {},
-          fontSize: 16
-        }
-      }
-    }).$mount()
-  })
-
-  it('string', done => {
-    vm.styles = 'color:red;'
-    waitForUpdate(() => {
-      expect(vm.$el.style.cssText.replace(/\s/g, '')).toBe('color:red;')
-    }).then(done)
-  })
-
-  it('falsy number', done => {
-    vm.styles = { opacity: 0 }
-    waitForUpdate(() => {
-      expect(vm.$el.style.opacity).toBe('0')
-    }).then(done)
-  })
-
-  it('plain object', done => {
-    vm.styles = { color: 'red' }
-    waitForUpdate(() => {
-      expect(vm.$el.style.cssText.replace(/\s/g, '')).toBe('color:red;')
-    }).then(done)
-  })
-
-  it('camelCase', done => {
-    vm.styles = { marginRight: '10px' }
-    waitForUpdate(() => {
-      expect(vm.$el.style.marginRight).toBe('10px')
-    }).then(done)
-  })
-
-  it('remove if falsy value', done => {
-    vm.$el.style.color = 'red'
-    waitForUpdate(() => {
-      vm.styles = { color: null }
-    }).then(() => {
-      expect(vm.$el.style.color).toBe('')
-    }).then(done)
-  })
-
-  it('ignore unsupported property', done => {
-    vm.styles = { foo: 'bar' }
-    waitForUpdate(() => {
-      expect(vm.$el.style.foo).not.toBe('bar')
-    }).then(done)
-  })
-
-  it('auto prefix', done => {
-    const prop = checkPrefixedProp('transform')
-    const val = 'scale(0.5)'
-    vm.styles = { transform: val }
-    waitForUpdate(() => {
-      expect(vm.$el.style[prop]).toBe(val)
-    }).then(done)
-  })
-
-  it('auto-prefixed style value as array', done => {
-    vm.styles = { display: ['-webkit-box', '-ms-flexbox', 'flex'] }
-    const testEl = document.createElement('div')
-    vm.styles.display.forEach(value => {
-      testEl.style.display = value
-    })
-    waitForUpdate(() => {
-      expect(vm.$el.style.display).toBe(testEl.style.display)
-    }).then(done)
-  })
-
-  it('!important', done => {
-    vm.styles = { display: 'block !important' }
-    waitForUpdate(() => {
-      expect(vm.$el.style.getPropertyPriority('display')).toBe('important')
-    }).then(done)
-  })
-
-  it('camelCase with !important', done => {
-    vm.styles = { zIndex: '100 !important' }
-    waitForUpdate(() => {
-      expect(vm.$el.style.getPropertyPriority('z-index')).toBe('important')
-    }).then(done)
-  })
-
-  it('object with multiple entries', done => {
-    vm.$el.style.color = 'red'
-    vm.styles = {
-      marginLeft: '10px',
-      marginRight: '15px'
-    }
-    waitForUpdate(() => {
-      expect(vm.$el.style.getPropertyValue('color')).toBe('red')
-      expect(vm.$el.style.getPropertyValue('margin-left')).toBe('10px')
-      expect(vm.$el.style.getPropertyValue('margin-right')).toBe('15px')
-      vm.styles = {
-        color: 'blue',
-        padding: null
-      }
-    }).then(() => {
-      expect(vm.$el.style.getPropertyValue('color')).toBe('blue')
-      expect(vm.$el.style.getPropertyValue('padding')).toBeFalsy()
-      expect(vm.$el.style.getPropertyValue('margin-left')).toBeFalsy()
-      expect(vm.$el.style.getPropertyValue('margin-right')).toBeFalsy()
-      // handle falsy value
-      vm.styles = null
-    }).then(() => {
-      expect(vm.$el.style.getPropertyValue('color')).toBeFalsy()
-      expect(vm.$el.style.getPropertyValue('padding')).toBeFalsy()
-      expect(vm.$el.style.getPropertyValue('margin-left')).toBeFalsy()
-      expect(vm.$el.style.getPropertyValue('margin-right')).toBeFalsy()
-    }).then(done)
-  })
-
-  it('array of objects', done => {
-    vm.$el.style.padding = '10px'
-    vm.styles = [{ color: 'red' }, { marginRight: '20px' }]
-
-    waitForUpdate(() => {
-      expect(vm.$el.style.getPropertyValue('color')).toBe('red')
-      expect(vm.$el.style.getPropertyValue('margin-right')).toBe('20px')
-      expect(vm.$el.style.getPropertyValue('padding')).toBe('10px')
-      vm.styles = [{ color: 'blue' }, { padding: null }]
-    }).then(() => {
-      expect(vm.$el.style.getPropertyValue('color')).toBe('blue')
-      expect(vm.$el.style.getPropertyValue('margin-right')).toBeFalsy()
-      expect(vm.$el.style.getPropertyValue('padding')).toBeFalsy()
-    }).then(done)
-  })
-
-  it('updates objects deeply', done => {
-    vm.styles = { display: 'none' }
-    waitForUpdate(() => {
-      expect(vm.$el.style.display).toBe('none')
-      vm.styles.display = 'block'
-    }).then(() => {
-      expect(vm.$el.style.display).toBe('block')
-    }).then(done)
-  })
-
-  it('background size with only one value', done => {
-    vm.styles = { backgroundSize: '100%' }
-    waitForUpdate(() => {
-      expect(vm.$el.style.cssText.replace(/\s/g, '')).toMatch(/background-size:100%(auto)?;/)
-    }).then(done)
-  })
-
-  it('should work with interpolation', done => {
-    vm.styles = { fontSize: `${vm.fontSize}px` }
-    waitForUpdate(() => {
-      expect(vm.$el.style.fontSize).toBe('16px')
-    }).then(done)
-  })
-
-  const supportCssVariable = () => {
-    const el = document.createElement('div')
-    el.style.setProperty('--color', 'red')
-    return el.style.getPropertyValue('--color') === 'red'
-  }
-
-  if (supportCssVariable()) {
-    it('CSS variables', done => {
-      vm.styles = { '--color': 'red' }
-      waitForUpdate(() => {
-        expect(vm.$el.style.getPropertyValue('--color')).toBe('red')
-      }).then(done)
-    })
-  }
-
-  it('should merge static style with binding style', () => {
-    const vm = new Vue({
-      template: '<div style="background: url(https://vuejs.org/images/logo.png);color: blue" :style="test"></div>',
-      data: {
-        test: { color: 'red', fontSize: '12px' }
-      }
-    }).$mount()
-    const style = vm.$el.style
-    expect(style.getPropertyValue('background-image')).toMatch('https://vuejs.org/images/logo.png')
-    expect(style.getPropertyValue('color')).toBe('red')
-    expect(style.getPropertyValue('font-size')).toBe('12px')
-  })
-
-  it('should merge between parent and child', done => {
-    const vm = new Vue({
-      template: '<child style="text-align: left;margin-right:20px" :style="test"></child>',
-      data: {
-        test: { color: 'red', fontSize: '12px' }
-      },
-      components: {
-        child: {
-          template: '<div style="margin-right:10px;" :style="{marginLeft: marginLeft}"></div>',
-          data: () => ({ marginLeft: '16px' })
-        }
-      }
-    }).$mount()
-    const style = vm.$el.style
-    const child = vm.$children[0]
-    const css = style.cssText.replace(/\s/g, '')
-    expect(css).toContain('margin-right:20px;')
-    expect(css).toContain('margin-left:16px;')
-    expect(css).toContain('text-align:left;')
-    expect(css).toContain('color:red;')
-    expect(css).toContain('font-size:12px;')
-    expect(style.color).toBe('red')
-    expect(style.marginRight).toBe('20px')
-    vm.test.color = 'blue'
-    waitForUpdate(() => {
-      expect(style.color).toBe('blue')
-      child.marginLeft = '30px'
-    }).then(() => {
-      expect(style.marginLeft).toBe('30px')
-      child.fontSize = '30px'
-    }).then(() => {
-      expect(style.fontSize).toBe('12px')
-    }).then(done)
-  })
-
-  it('should not pass to child root element', () => {
-    const vm = new Vue({
-      template: '<child :style="test"></child>',
-      data: {
-        test: { color: 'red', fontSize: '12px' }
-      },
-      components: {
-        child: {
-          template: '<div><nested ref="nested" style="color: blue;text-align:left"></nested></div>',
-          components: {
-            nested: {
-              template: '<div></div>'
-            }
-          }
-        }
-      }
-    }).$mount()
-    const style = vm.$el.style
-    expect(style.color).toBe('red')
-    expect(style.textAlign).toBe('')
-    expect(style.fontSize).toBe('12px')
-    expect(vm.$children[0].$refs.nested.$el.style.color).toBe('blue')
-  })
-
-  it('should merge between nested components', (done) => {
-    const vm = new Vue({
-      template: '<child :style="test"></child>',
-      data: {
-        test: { color: 'red', fontSize: '12px' }
-      },
-      components: {
-        child: {
-          template: '<nested style="color: blue;text-align:left"></nested>',
-          components: {
-            nested: {
-              template: '<div style="margin-left: 12px;" :style="nestedStyle"></div>',
-              data: () => ({ nestedStyle: { marginLeft: '30px' }})
-            }
-          }
-        }
-      }
-    }).$mount()
-    const style = vm.$el.style
-    const child = vm.$children[0].$children[0]
-    expect(style.color).toBe('red')
-    expect(style.marginLeft).toBe('30px')
-    expect(style.textAlign).toBe('left')
-    expect(style.fontSize).toBe('12px')
-    vm.test.color = 'yellow'
-    waitForUpdate(() => {
-      child.nestedStyle.marginLeft = '60px'
-    }).then(() => {
-      expect(style.marginLeft).toBe('60px')
-      child.nestedStyle = {
-        fontSize: '14px',
-        marginLeft: '40px'
-      }
-    }).then(() => {
-      expect(style.fontSize).toBe('12px')
-      expect(style.marginLeft).toBe('40px')
-    }).then(done)
-  })
-
-  it('should not merge for different adjacent elements', (done) => {
-    const vm = new Vue({
-      template:
-        '<div>' +
-          '<section style="color: blue" :style="style" v-if="!bool"></section>' +
-          '<div></div>' +
-          '<section style="margin-top: 12px" v-if="bool"></section>' +
-        '</div>',
-      data: {
-        bool: false,
-        style: {
-          fontSize: '12px'
-        }
-      }
-    }).$mount()
-    const style = vm.$el.children[0].style
-    expect(style.fontSize).toBe('12px')
-    expect(style.color).toBe('blue')
-    waitForUpdate(() => {
-      vm.bool = true
-    }).then(() => {
-      expect(style.color).toBe('')
-      expect(style.fontSize).toBe('')
-      expect(style.marginTop).toBe('12px')
-    }).then(done)
-  })
-
-  it('should not merge for v-if, v-else-if and v-else elements', (done) => {
-    const vm = new Vue({
-      template:
-        '<div>' +
-          '<section style="color: blue" :style="style" v-if="foo"></section>' +
-          '<section style="margin-top: 12px" v-else-if="bar"></section>' +
-          '<section style="margin-bottom: 24px" v-else></section>' +
-          '<div></div>' +
-        '</div>',
-      data: {
-        foo: true,
-        bar: false,
-        style: {
-          fontSize: '12px'
-        }
-      }
-    }).$mount()
-    const style = vm.$el.children[0].style
-    expect(style.fontSize).toBe('12px')
-    expect(style.color).toBe('blue')
-    waitForUpdate(() => {
-      vm.foo = false
-    }).then(() => {
-      expect(style.color).toBe('')
-      expect(style.fontSize).toBe('')
-      expect(style.marginBottom).toBe('24px')
-      vm.bar = true
-    }).then(() => {
-      expect(style.color).toBe('')
-      expect(style.fontSize).toBe('')
-      expect(style.marginBottom).toBe('')
-      expect(style.marginTop).toBe('12px')
-    }).then(done)
-  })
-
-  // #5318
-  it('should work for elements passed down as a slot', done => {
-    const vm = new Vue({
-      template: `<test><div :style="style"/></test>`,
-      data: {
-        style: { color: 'red' }
-      },
-      components: {
-        test: {
-          template: `<div><slot/></div>`
-        }
-      }
-    }).$mount()
-
-    expect(vm.$el.children[0].style.color).toBe('red')
-    vm.style.color = 'green'
-    waitForUpdate(() => {
-      expect(vm.$el.children[0].style.color).toBe('green')
-    }).then(done)
-  })
-})
diff --git a/1.Vue/test/unit/features/directives/text.spec.js b/1.Vue/test/unit/features/directives/text.spec.js
deleted file mode 100644
index 84f9bbe..0000000
--- a/1.Vue/test/unit/features/directives/text.spec.js
+++ /dev/null
@@ -1,59 +0,0 @@
-import Vue from 'vue'
-
-describe('Directive v-text', () => {
-  it('should render text', () => {
-    const vm = new Vue({
-      template: '<div v-text="a"></div>',
-      data: { a: 'hello' }
-    }).$mount()
-    expect(vm.$el.innerHTML).toBe('hello')
-  })
-
-  it('should encode html entities', () => {
-    const vm = new Vue({
-      template: '<div v-text="a"></div>',
-      data: { a: '<foo>' }
-    }).$mount()
-    expect(vm.$el.innerHTML).toBe('&lt;foo&gt;')
-  })
-
-  it('should support all value types', done => {
-    const vm = new Vue({
-      template: '<div v-text="a"></div>',
-      data: { a: false }
-    }).$mount()
-    waitForUpdate(() => {
-      expect(vm.$el.innerHTML).toBe('false')
-      vm.a = []
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('[]')
-      vm.a = {}
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('{}')
-      vm.a = { toString () { return 'foo' } }
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('foo')
-      vm.a = { toJSON () { return { foo: 'bar' } } }
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('{\n  "foo": "bar"\n}')
-      vm.a = 123
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('123')
-      vm.a = 0
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('0')
-      vm.a = ' '
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe(' ')
-      vm.a = '    '
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('    ')
-      vm.a = null
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('')
-      vm.a = undefined
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('')
-    }).then(done)
-  })
-})
diff --git a/1.Vue/test/unit/features/error-handling.spec.js b/1.Vue/test/unit/features/error-handling.spec.js
deleted file mode 100644
index 7d0eaa5..0000000
--- a/1.Vue/test/unit/features/error-handling.spec.js
+++ /dev/null
@@ -1,424 +0,0 @@
-import Vue from 'vue'
-
-const components = createErrorTestComponents()
-
-describe('Error handling', () => {
-  // hooks that prevents the component from rendering, but should not
-  // break parent component
-  [
-    ['data', 'data()'],
-    ['render', 'render'],
-    ['beforeCreate', 'beforeCreate hook'],
-    ['created', 'created hook'],
-    ['beforeMount', 'beforeMount hook'],
-    ['directive bind', 'directive foo bind hook'],
-    ['event', 'event handler for "e"']
-  ].forEach(([type, description]) => {
-    it(`should recover from errors in ${type}`, done => {
-      const vm = createTestInstance(components[type])
-      expect(`Error in ${description}`).toHaveBeenWarned()
-      expect(`Error: ${type}`).toHaveBeenWarned()
-      assertRootInstanceActive(vm).then(done)
-    })
-  })
-
-  // hooks that can return rejected promise
-  ;[
-    ['beforeCreate', 'beforeCreate hook'],
-    ['created', 'created hook'],
-    ['beforeMount', 'beforeMount hook'],
-    ['mounted', 'mounted hook'],
-    ['event', 'event handler for "e"']
-  ].forEach(([type, description]) => {
-    it(`should recover from promise errors in ${type}`, done => {
-      createTestInstance(components[`${type}Async`])
-      waitForUpdate(() => {
-        expect(`Error in ${description} (Promise/async)`).toHaveBeenWarned()
-        expect(`Error: ${type}`).toHaveBeenWarned()
-      }).then(done)
-    })
-  })
-
-  // error in mounted hook should affect neither child nor parent
-  it('should recover from errors in mounted hook', done => {
-    const vm = createTestInstance(components.mounted)
-    expect(`Error in mounted hook`).toHaveBeenWarned()
-    expect(`Error: mounted`).toHaveBeenWarned()
-    assertBothInstancesActive(vm).then(done)
-  })
-
-  // error in beforeUpdate/updated should affect neither child nor parent
-  ;[
-    ['beforeUpdate', 'beforeUpdate hook'],
-    ['updated', 'updated hook'],
-    ['directive update', 'directive foo update hook']
-  ].forEach(([type, description]) => {
-    it(`should recover from errors in ${type} hook`, done => {
-      const vm = createTestInstance(components[type])
-      assertBothInstancesActive(vm).then(() => {
-        expect(`Error in ${description}`).toHaveBeenWarned()
-        expect(`Error: ${type}`).toHaveBeenWarned()
-      }).then(done)
-    })
-  })
-
-  // hooks that can return rejected promise
-  ;[
-    ['beforeUpdate', 'beforeUpdate hook'],
-    ['updated', 'updated hook']
-  ].forEach(([type, description]) => {
-    it(`should recover from promise errors in ${type} hook`, done => {
-      const vm = createTestInstance(components[`${type}Async`])
-      assertBothInstancesActive(vm).then(() => {
-        expect(`Error in ${description} (Promise/async)`).toHaveBeenWarned()
-        expect(`Error: ${type}`).toHaveBeenWarned()
-      }).then(done)
-    })
-  })
-
-  ;[
-    ['beforeDestroy', 'beforeDestroy hook'],
-    ['destroyed', 'destroyed hook'],
-    ['directive unbind', 'directive foo unbind hook']
-  ].forEach(([type, description]) => {
-    it(`should recover from errors in ${type} hook`, done => {
-      const vm = createTestInstance(components[type])
-      vm.ok = false
-      waitForUpdate(() => {
-        expect(`Error in ${description}`).toHaveBeenWarned()
-        expect(`Error: ${type}`).toHaveBeenWarned()
-      }).thenWaitFor(next => {
-        assertRootInstanceActive(vm).end(next)
-      }).then(done)
-    })
-  })
-
-  ;[
-    ['beforeDestroy', 'beforeDestroy hook'],
-    ['destroyed', 'destroyed hook']
-  ].forEach(([type, description]) => {
-    it(`should recover from promise errors in ${type} hook`, done => {
-      const vm = createTestInstance(components[`${type}Async`])
-      vm.ok = false
-      setTimeout(() => {
-        expect(`Error in ${description} (Promise/async)`).toHaveBeenWarned()
-        expect(`Error: ${type}`).toHaveBeenWarned()
-        assertRootInstanceActive(vm).then(done)
-      })
-    })
-  })
-
-  it('should recover from errors in user watcher getter', done => {
-    const vm = createTestInstance(components.userWatcherGetter)
-    vm.n++
-    waitForUpdate(() => {
-      expect(`Error in getter for watcher`).toHaveBeenWarned()
-      function getErrorMsg () {
-        try {
-          this.a.b.c
-        } catch (e) {
-          return e.toString()
-        }
-      }
-      const msg = getErrorMsg.call(vm)
-      expect(msg).toHaveBeenWarned()
-    }).thenWaitFor(next => {
-      assertBothInstancesActive(vm).end(next)
-    }).then(done)
-  })
-
-  it('should recover from errors in user watcher callback', done => {
-    const vm = createTestInstance(components.userWatcherCallback)
-    vm.n++
-    waitForUpdate(() => {
-      expect(`Error in callback for watcher "n"`).toHaveBeenWarned()
-      expect(`Error: userWatcherCallback`).toHaveBeenWarned()
-    }).thenWaitFor(next => {
-      assertBothInstancesActive(vm).end(next)
-    }).then(done)
-  })
-
-  it('should recover from errors in user immediate watcher callback', done => {
-    const vm = createTestInstance(components.userImmediateWatcherCallback)
-    waitForUpdate(() => {
-      expect(`Error in callback for immediate watcher "n"`).toHaveBeenWarned()
-      expect(`Error: userImmediateWatcherCallback error`).toHaveBeenWarned()
-    }).thenWaitFor(next => {
-      assertBothInstancesActive(vm).end(next)
-    }).then(done)
-  })
-
-  it('config.errorHandler should capture render errors', done => {
-    const spy = Vue.config.errorHandler = jasmine.createSpy('errorHandler')
-    const vm = createTestInstance(components.render)
-
-    const args = spy.calls.argsFor(0)
-    expect(args[0].toString()).toContain('Error: render') // error
-    expect(args[1]).toBe(vm.$refs.child) // vm
-    expect(args[2]).toContain('render') // description
-
-    assertRootInstanceActive(vm).then(() => {
-      Vue.config.errorHandler = null
-    }).then(done)
-  })
-
-  it('should capture and recover from nextTick errors', done => {
-    const err1 = new Error('nextTick')
-    const err2 = new Error('nextTick2')
-    const spy = Vue.config.errorHandler = jasmine.createSpy('errorHandler')
-    Vue.nextTick(() => { throw err1 })
-    Vue.nextTick(() => {
-      expect(spy).toHaveBeenCalledWith(err1, undefined, 'nextTick')
-
-      const vm = new Vue()
-      vm.$nextTick(() => { throw err2 })
-      Vue.nextTick(() => {
-        // should be called with correct instance info
-        expect(spy).toHaveBeenCalledWith(err2, vm, 'nextTick')
-        Vue.config.errorHandler = null
-        done()
-      })
-    })
-  })
-
-  it('should recover from errors thrown in errorHandler itself', () => {
-    Vue.config.errorHandler = () => {
-      throw new Error('error in errorHandler ¯\\_(ツ)_/¯')
-    }
-    const vm = new Vue({
-      render (h) {
-        throw new Error('error in render')
-      },
-      renderError (h, err) {
-        return h('div', err.toString())
-      }
-    }).$mount()
-    expect('error in errorHandler').toHaveBeenWarned()
-    expect('error in render').toHaveBeenWarned()
-    expect(vm.$el.textContent).toContain('error in render')
-    Vue.config.errorHandler = null
-  })
-
-  // event handlers that can throw errors or return rejected promise
-  ;[
-    ['single handler', '<div v-on:click="bork"></div>'],
-    ['multiple handlers', '<div v-on="{ click: [bork, function test() {}] }"></div>']
-  ].forEach(([type, template]) => {
-    it(`should recover from v-on errors for ${type} registered`, () => {
-      const vm = new Vue({
-        template,
-        methods: { bork () { throw new Error('v-on') } }
-      }).$mount()
-      document.body.appendChild(vm.$el)
-      triggerEvent(vm.$el, 'click')
-      expect('Error in v-on handler').toHaveBeenWarned()
-      expect('Error: v-on').toHaveBeenWarned()
-      document.body.removeChild(vm.$el)
-    })
-
-    it(`should recover from v-on async errors for ${type} registered`, (done) => {
-      const vm = new Vue({
-        template,
-        methods: { bork () {
-          return new Promise((resolve, reject) => reject(new Error('v-on async')))
-        } }
-      }).$mount()
-      document.body.appendChild(vm.$el)
-      triggerEvent(vm.$el, 'click')
-      waitForUpdate(() => {
-        expect('Error in v-on handler (Promise/async)').toHaveBeenWarned()
-        expect('Error: v-on').toHaveBeenWarned()
-        document.body.removeChild(vm.$el)
-      }).then(done)
-    })
-  })
-})
-
-function createErrorTestComponents () {
-  const components = {}
-
-  // data
-  components.data = {
-    data () {
-      throw new Error('data')
-    },
-    render (h) {
-      return h('div')
-    }
-  }
-
-  // render error
-  components.render = {
-    render (h) {
-      throw new Error('render')
-    }
-  }
-
-  // lifecycle errors
-  ;['create', 'mount', 'update', 'destroy'].forEach(hook => {
-    // before
-    const before = 'before' + hook.charAt(0).toUpperCase() + hook.slice(1)
-    const beforeComp = components[before] = {
-      props: ['n'],
-      render (h) {
-        return h('div', this.n)
-      }
-    }
-    beforeComp[before] = function () {
-      throw new Error(before)
-    }
-
-    const beforeCompAsync = components[`${before}Async`] = {
-      props: ['n'],
-      render (h) {
-        return h('div', this.n)
-      }
-    }
-    beforeCompAsync[before] = function () {
-      return new Promise((resolve, reject) => reject(new Error(before)))
-    }
-
-    // after
-    const after = hook.replace(/e?$/, 'ed')
-    const afterComp = components[after] = {
-      props: ['n'],
-      render (h) {
-        return h('div', this.n)
-      }
-    }
-    afterComp[after] = function () {
-      throw new Error(after)
-    }
-
-    const afterCompAsync = components[`${after}Async`] = {
-      props: ['n'],
-      render (h) {
-        return h('div', this.n)
-      }
-    }
-    afterCompAsync[after] = function () {
-      return new Promise((resolve, reject) => reject(new Error(after)))
-    }
-  })
-
-  // directive hooks errors
-  ;['bind', 'update', 'unbind'].forEach(hook => {
-    const key = 'directive ' + hook
-    const dirComp = components[key] = {
-      props: ['n'],
-      template: `<div v-foo="n">{{ n }}</div>`
-    }
-    const dirFoo = {}
-    dirFoo[hook] = function () {
-      throw new Error(key)
-    }
-    dirComp.directives = {
-      foo: dirFoo
-    }
-  })
-
-  // user watcher
-  components.userWatcherGetter = {
-    props: ['n'],
-    created () {
-      this.$watch(function () {
-        return this.n + this.a.b.c
-      }, val => {
-        console.log('user watcher fired: ' + val)
-      })
-    },
-    render (h) {
-      return h('div', this.n)
-    }
-  }
-
-  components.userWatcherCallback = {
-    props: ['n'],
-    watch: {
-      n () {
-        throw new Error('userWatcherCallback error')
-      }
-    },
-    render (h) {
-      return h('div', this.n)
-    }
-  }
-
-  components.userImmediateWatcherCallback = {
-    props: ['n'],
-    watch: {
-      n: {
-        immediate: true,
-        handler () {
-          throw new Error('userImmediateWatcherCallback error')
-        }
-      }
-    },
-    render (h) {
-      return h('div', this.n)
-    }
-  }
-
-  // event errors
-  components.event = {
-    beforeCreate () {
-      this.$on('e', () => { throw new Error('event') })
-    },
-    mounted () {
-      this.$emit('e')
-    },
-    render (h) {
-      return h('div')
-    }
-  }
-
-  components.eventAsync = {
-    beforeCreate () {
-      this.$on('e', () => new Promise((resolve, reject) => reject(new Error('event'))))
-    },
-    mounted () {
-      this.$emit('e')
-    },
-    render (h) {
-      return h('div')
-    }
-  }
-
-  return components
-}
-
-function createTestInstance (Comp) {
-  return new Vue({
-    data: {
-      n: 0,
-      ok: true
-    },
-    render (h) {
-      return h('div', [
-        'n:' + this.n + '\n',
-        this.ok
-          ? h(Comp, { ref: 'child', props: { n: this.n }})
-          : null
-      ])
-    }
-  }).$mount()
-}
-
-function assertRootInstanceActive (vm, chain) {
-  expect(vm.$el.innerHTML).toContain('n:0\n')
-  vm.n++
-  return waitForUpdate(() => {
-    expect(vm.$el.innerHTML).toContain('n:1\n')
-  })
-}
-
-function assertBothInstancesActive (vm) {
-  vm.n = 0
-  return waitForUpdate(() => {
-    expect(vm.$refs.child.$el.innerHTML).toContain('0')
-  }).thenWaitFor(next => {
-    assertRootInstanceActive(vm).then(() => {
-      expect(vm.$refs.child.$el.innerHTML).toContain('1')
-    }).end(next)
-  })
-}
diff --git a/1.Vue/test/unit/features/filter/filter.spec.js b/1.Vue/test/unit/features/filter/filter.spec.js
deleted file mode 100644
index 82c57a3..0000000
--- a/1.Vue/test/unit/features/filter/filter.spec.js
+++ /dev/null
@@ -1,197 +0,0 @@
-import Vue from 'vue'
-import { parseFilters } from 'compiler/parser/filter-parser'
-
-describe('Filters', () => {
-  it('basic usage', () => {
-    const vm = new Vue({
-      template: '<div>{{ msg | upper }}</div>',
-      data: {
-        msg: 'hi'
-      },
-      filters: {
-        upper: v => v.toUpperCase()
-      }
-    }).$mount()
-    expect(vm.$el.textContent).toBe('HI')
-  })
-
-  it('chained usage', () => {
-    const vm = new Vue({
-      template: '<div>{{ msg | upper | reverse }}</div>',
-      data: {
-        msg: 'hi'
-      },
-      filters: {
-        upper: v => v.toUpperCase(),
-        reverse: v => v.split('').reverse().join('')
-      }
-    }).$mount()
-    expect(vm.$el.textContent).toBe('IH')
-  })
-
-  it('in v-bind', () => {
-    const vm = new Vue({
-      template: `
-        <div
-          v-bind:id="id | upper | reverse"
-          :class="cls | reverse"
-          :ref="ref | lower">
-        </div>
-      `,
-      filters: {
-        upper: v => v.toUpperCase(),
-        reverse: v => v.split('').reverse().join(''),
-        lower: v => v.toLowerCase()
-      },
-      data: {
-        id: 'abc',
-        cls: 'foo',
-        ref: 'BAR'
-      }
-    }).$mount()
-    expect(vm.$el.id).toBe('CBA')
-    expect(vm.$el.className).toBe('oof')
-    expect(vm.$refs.bar).toBe(vm.$el)
-  })
-
-  it('handle regex with pipe', () => {
-    const vm = new Vue({
-      template: `<test ref="test" :pattern="/a|b\\// | identity"></test>`,
-      filters: { identity: v => v },
-      components: {
-        test: {
-          props: ['pattern'],
-          template: '<div></div>'
-        }
-      }
-    }).$mount()
-    expect(vm.$refs.test.pattern instanceof RegExp).toBe(true)
-    expect(vm.$refs.test.pattern.toString()).toBe('/a|b\\//')
-  })
-
-  it('handle division', () => {
-    const vm = new Vue({
-      data: { a: 2 },
-      template: `<div>{{ 1/a / 4 | double }}</div>`,
-      filters: { double: v => v * 2 }
-    }).$mount()
-    expect(vm.$el.textContent).toBe(String(1 / 4))
-  })
-
-  it('handle division with parenthesis', () => {
-    const vm = new Vue({
-      data: { a: 20 },
-      template: `<div>{{ (a*2) / 5 | double }}</div>`,
-      filters: { double: v => v * 2 }
-    }).$mount()
-    expect(vm.$el.textContent).toBe(String(16))
-  })
-
-  it('handle division with dot', () => {
-    const vm = new Vue({
-      template: `<div>{{ 20. / 5 | double }}</div>`,
-      filters: { double: v => v * 2 }
-    }).$mount()
-    expect(vm.$el.textContent).toBe(String(8))
-  })
-
-  it('handle division with array values', () => {
-    const vm = new Vue({
-      data: { a: [20] },
-      template: `<div>{{ a[0] / 5 | double }}</div>`,
-      filters: { double: v => v * 2 }
-    }).$mount()
-    expect(vm.$el.textContent).toBe(String(8))
-  })
-
-  it('handle division with hash values', () => {
-    const vm = new Vue({
-      data: { a: { n: 20 }},
-      template: `<div>{{ a['n'] / 5 | double }}</div>`,
-      filters: { double: v => v * 2 }
-    }).$mount()
-    expect(vm.$el.textContent).toBe(String(8))
-  })
-
-  it('handle division with variable_', () => {
-    const vm = new Vue({
-      data: { a_: 8 },
-      template: `<div>{{ a_ / 2 | double }}</div>`,
-      filters: { double: v => v * 2 }
-    }).$mount()
-    expect(vm.$el.textContent).toBe(String(8))
-  })
-
-  it('arguments', () => {
-    const vm = new Vue({
-      template: `<div>{{ msg | add(a, 3) }}</div>`,
-      data: {
-        msg: 1,
-        a: 2
-      },
-      filters: {
-        add: (v, arg1, arg2) => v + arg1 + arg2
-      }
-    }).$mount()
-    expect(vm.$el.textContent).toBe('6')
-  })
-
-  it('quotes', () => {
-    const vm = new Vue({
-      template: `<div>{{ msg + "b | c" + 'd' | upper }}</div>`,
-      data: {
-        msg: 'a'
-      },
-      filters: {
-        upper: v => v.toUpperCase()
-      }
-    }).$mount()
-    expect(vm.$el.textContent).toBe('AB | CD')
-  })
-
-  it('double pipe', () => {
-    const vm = new Vue({
-      template: `<div>{{ b || msg | upper }}</div>`,
-      data: {
-        b: false,
-        msg: 'a'
-      },
-      filters: {
-        upper: v => v.toUpperCase()
-      }
-    }).$mount()
-    expect(vm.$el.textContent).toBe('A')
-  })
-
-  it('object literal', () => {
-    const vm = new Vue({
-      template: `<div>{{ { a: 123 } | pick('a') }}</div>`,
-      filters: {
-        pick: (v, key) => v[key]
-      }
-    }).$mount()
-    expect(vm.$el.textContent).toBe('123')
-  })
-
-  it('array literal', () => {
-    const vm = new Vue({
-      template: `<div>{{ [1, 2, 3] | reverse }}</div>`,
-      filters: {
-        reverse: arr => arr.reverse().join(',')
-      }
-    }).$mount()
-    expect(vm.$el.textContent).toBe('3,2,1')
-  })
-
-  it('warn non-existent', () => {
-    new Vue({
-      template: '<div>{{ msg | upper }}</div>',
-      data: { msg: 'foo' }
-    }).$mount()
-    expect('Failed to resolve filter: upper').toHaveBeenWarned()
-  })
-
-  it('support template string', () => {
-    expect(parseFilters('`a | ${b}c` | d')).toBe('_f("d")(`a | ${b}c`)')
-  })
-})
diff --git a/1.Vue/test/unit/features/global-api/assets.spec.js b/1.Vue/test/unit/features/global-api/assets.spec.js
deleted file mode 100644
index 41e6b5f..0000000
--- a/1.Vue/test/unit/features/global-api/assets.spec.js
+++ /dev/null
@@ -1,68 +0,0 @@
-import Vue from 'vue'
-
-describe('Global API: assets', () => {
-  const Test = Vue.extend()
-
-  it('directive / filters', () => {
-    const assets = ['directive', 'filter']
-    assets.forEach(function (type) {
-      const def = {}
-      Test[type]('test', def)
-      expect(Test.options[type + 's'].test).toBe(def)
-      expect(Test[type]('test')).toBe(def)
-      // extended registration should not pollute global
-      expect(Vue.options[type + 's'].test).toBeUndefined()
-    })
-  })
-
-  describe('Vue.component', () => {
-    it('should register a component', () => {
-      Vue.component('foo', {
-        template: '<span>foo</span>'
-      })
-      Vue.component('bar', {
-        template: '<span>bar</span>'
-      })
-      const vm = new Vue({
-        template: '<div><foo></foo><bar></bar></div>'
-      }).$mount()
-      expect(vm.$el.innerHTML).toBe('<span>foo</span><span>bar</span>')
-      // unregister them
-      delete Vue.options.components.foo
-      delete Vue.options.components.bar
-    })
-  })
-
-  it('component on extended constructor', () => {
-    const def = { a: 1 }
-    Test.component('test', def)
-    const component = Test.options.components.test
-    expect(typeof component).toBe('function')
-    expect(component.super).toBe(Vue)
-    expect(component.options.a).toBe(1)
-    expect(component.options.name).toBe('test')
-    expect(Test.component('test')).toBe(component)
-    // already extended
-    Test.component('test2', component)
-    expect(Test.component('test2')).toBe(component)
-    // extended registration should not pollute global
-    expect(Vue.options.components.test).toBeUndefined()
-  })
-
-  // #4434
-  it('local registration should take priority regardless of naming convention', () => {
-    Vue.component('x-foo', {
-      template: '<span>global</span>'
-    })
-    const vm = new Vue({
-      components: {
-        xFoo: {
-          template: '<span>local</span>'
-        }
-      },
-      template: '<div><x-foo></x-foo></div>'
-    }).$mount()
-    expect(vm.$el.textContent).toBe('local')
-    delete Vue.options.components['x-foo']
-  })
-})
diff --git a/1.Vue/test/unit/features/global-api/compile.spec.js b/1.Vue/test/unit/features/global-api/compile.spec.js
deleted file mode 100644
index 64ce0ee..0000000
--- a/1.Vue/test/unit/features/global-api/compile.spec.js
+++ /dev/null
@@ -1,15 +0,0 @@
-import Vue from 'vue'
-
-describe('Global API: compile', () => {
-  it('should compile render functions', () => {
-    const res = Vue.compile('<div><span>{{ msg }}</span></div>')
-    const vm = new Vue({
-      data: {
-        msg: 'hello'
-      },
-      render: res.render,
-      staticRenderFns: res.staticRenderFns
-    }).$mount()
-    expect(vm.$el.innerHTML).toContain('<span>hello</span>')
-  })
-})
diff --git a/1.Vue/test/unit/features/global-api/config.spec.js b/1.Vue/test/unit/features/global-api/config.spec.js
deleted file mode 100644
index f2e5074..0000000
--- a/1.Vue/test/unit/features/global-api/config.spec.js
+++ /dev/null
@@ -1,125 +0,0 @@
-import Vue from 'vue'
-import { warn } from 'core/util/debug'
-
-describe('Global config', () => {
-  it('should warn replacing config object', () => {
-    const originalConfig = Vue.config
-    Vue.config = {}
-    expect(Vue.config).toBe(originalConfig)
-    expect('Do not replace the Vue.config object').toHaveBeenWarned()
-  })
-
-  describe('silent', () => {
-    it('should be false by default', () => {
-      warn('foo')
-      expect('foo').toHaveBeenWarned()
-    })
-
-    it('should work when set to true', () => {
-      Vue.config.silent = true
-      warn('foo')
-      expect('foo').not.toHaveBeenWarned()
-      Vue.config.silent = false
-    })
-  })
-
-  describe('optionMergeStrategies', () => {
-    it('should allow defining custom option merging strategies', () => {
-      const spy = jasmine.createSpy('option merging')
-      Vue.config.optionMergeStrategies.__test__ = (parent, child, vm) => {
-        spy(parent, child, vm)
-        return child + 1
-      }
-      const Test = Vue.extend({
-        __test__: 1
-      })
-      expect(spy.calls.count()).toBe(1)
-      expect(spy).toHaveBeenCalledWith(undefined, 1, undefined)
-      expect(Test.options.__test__).toBe(2)
-      const test = new Test({
-        __test__: 2
-      })
-      expect(spy.calls.count()).toBe(2)
-      expect(spy).toHaveBeenCalledWith(2, 2, test)
-      expect(test.$options.__test__).toBe(3)
-    })
-  })
-
-  describe('ignoredElements', () => {
-    it('should work', () => {
-      Vue.config.ignoredElements = ['foo', /^ion-/]
-      new Vue({
-        template: `<div><foo/><ion-foo/><ion-bar/></div>`
-      }).$mount()
-      expect('Unknown custom element').not.toHaveBeenWarned()
-      Vue.config.ignoredElements = []
-    })
-  })
-
-  describe('async', () => {
-    it('does not update synchronously when true', () => {
-      const spy = jasmine.createSpy()
-      const vm = new Vue({
-        template: `<div :class="value"></div>`,
-        updated: spy,
-        data: { value: true }
-      }).$mount()
-      vm.value = false
-      expect(spy).not.toHaveBeenCalled()
-    })
-
-    it('updates synchronously when false', () => {
-      const spy = jasmine.createSpy()
-      Vue.config.async = false
-      const vm = new Vue({
-        template: `<div :class="value"></div>`,
-        updated: spy,
-        data: { value: true }
-      }).$mount()
-      vm.value = false
-      expect(spy).toHaveBeenCalled()
-      Vue.config.async = true
-    })
-
-    it('runs watchers in correct order when false', () => {
-      Vue.config.async = false
-      const vm = new Vue({
-        template: `
-          <div id="app">
-            {{ computed }}
-          </div>`,
-        props: ['prop'],
-        propsData: {
-          'prop': []
-        },
-        data: () => ({
-          data: ''
-        }),
-        computed: {
-          computed () {
-            return this.prop.join(',')
-          }
-        },
-        watch: {
-          prop: 'execute'
-        },
-        methods: {
-          execute () {
-            this.data = this.computed
-          }
-        }
-      }).$mount()
-      expect(vm.computed).toBe('')
-      expect(vm.data).toBe('')
-
-      vm.prop = [1, 2, 3]
-      expect(vm.computed).toBe('1,2,3')
-      expect(vm.data).toBe('1,2,3')
-
-      vm.prop.push(4, 5)
-      expect(vm.computed).toBe('1,2,3,4,5')
-      expect(vm.data).toBe('1,2,3,4,5')
-      Vue.config.async = true
-    })
-  })
-})
diff --git a/1.Vue/test/unit/features/global-api/extend.spec.js b/1.Vue/test/unit/features/global-api/extend.spec.js
deleted file mode 100644
index f0867ac..0000000
--- a/1.Vue/test/unit/features/global-api/extend.spec.js
+++ /dev/null
@@ -1,153 +0,0 @@
-import Vue from 'vue'
-
-describe('Global API: extend', () => {
-  it('should correctly merge options', () => {
-    const Test = Vue.extend({
-      name: 'test',
-      a: 1,
-      b: 2
-    })
-    expect(Test.options.a).toBe(1)
-    expect(Test.options.b).toBe(2)
-    expect(Test.super).toBe(Vue)
-    const t = new Test({
-      a: 2
-    })
-    expect(t.$options.a).toBe(2)
-    expect(t.$options.b).toBe(2)
-    // inheritance
-    const Test2 = Test.extend({
-      a: 2
-    })
-    expect(Test2.options.a).toBe(2)
-    expect(Test2.options.b).toBe(2)
-    const t2 = new Test2({
-      a: 3
-    })
-    expect(t2.$options.a).toBe(3)
-    expect(t2.$options.b).toBe(2)
-  })
-
-  it('should warn invalid names', () => {
-    Vue.extend({ name: '123' })
-    expect('Invalid component name: "123"').toHaveBeenWarned()
-    Vue.extend({ name: '_fesf' })
-    expect('Invalid component name: "_fesf"').toHaveBeenWarned()
-    Vue.extend({ name: 'Some App' })
-    expect('Invalid component name: "Some App"').toHaveBeenWarned()
-  })
-
-  it('should work when used as components', () => {
-    const foo = Vue.extend({
-      template: '<span>foo</span>'
-    })
-    const bar = Vue.extend({
-      template: '<span>bar</span>'
-    })
-    const vm = new Vue({
-      template: '<div><foo></foo><bar></bar></div>',
-      components: { foo, bar }
-    }).$mount()
-    expect(vm.$el.innerHTML).toBe('<span>foo</span><span>bar</span>')
-  })
-
-  it('should merge lifecycle hooks', () => {
-    const calls = []
-    const A = Vue.extend({
-      created () {
-        calls.push(1)
-      }
-    })
-    const B = A.extend({
-      created () {
-        calls.push(2)
-      }
-    })
-    new B({
-      created () {
-        calls.push(3)
-      }
-    })
-    expect(calls).toEqual([1, 2, 3])
-  })
-
-  it('should not merge nested mixins created with Vue.extend', () => {
-    const A = Vue.extend({
-      created: () => {}
-    })
-    const B = Vue.extend({
-      mixins: [A],
-      created: () => {}
-    })
-    const C = Vue.extend({
-      extends: B,
-      created: () => {}
-    })
-    const D = Vue.extend({
-      mixins: [C],
-      created: () => {}
-    })
-    expect(D.options.created.length).toBe(4)
-  })
-
-  it('should merge methods', () => {
-    const A = Vue.extend({
-      methods: {
-        a () { return this.n }
-      }
-    })
-    const B = A.extend({
-      methods: {
-        b () { return this.n + 1 }
-      }
-    })
-    const b = new B({
-      data: { n: 0 },
-      methods: {
-        c () { return this.n + 2 }
-      }
-    })
-    expect(b.a()).toBe(0)
-    expect(b.b()).toBe(1)
-    expect(b.c()).toBe(2)
-  })
-
-  it('should merge assets', () => {
-    const A = Vue.extend({
-      components: {
-        aa: {
-          template: '<div>A</div>'
-        }
-      }
-    })
-    const B = A.extend({
-      components: {
-        bb: {
-          template: '<div>B</div>'
-        }
-      }
-    })
-    const b = new B({
-      template: '<div><aa></aa><bb></bb></div>'
-    }).$mount()
-    expect(b.$el.innerHTML).toBe('<div>A</div><div>B</div>')
-  })
-
-  it('caching', () => {
-    const options = {
-      template: '<div></div>'
-    }
-    const A = Vue.extend(options)
-    const B = Vue.extend(options)
-    expect(A).toBe(B)
-  })
-
-  // #4767
-  it('extended options should use different identify from parent', () => {
-    const A = Vue.extend({ computed: {}})
-    const B = A.extend()
-    B.options.computed.b = () => 'foo'
-    expect(B.options.computed).not.toBe(A.options.computed)
-    expect(A.options.computed.b).toBeUndefined()
-  })
-})
diff --git a/1.Vue/test/unit/features/global-api/mixin.spec.js b/1.Vue/test/unit/features/global-api/mixin.spec.js
deleted file mode 100644
index 14b6591..0000000
--- a/1.Vue/test/unit/features/global-api/mixin.spec.js
+++ /dev/null
@@ -1,197 +0,0 @@
-import Vue from 'vue'
-
-describe('Global API: mixin', () => {
-  let options
-  beforeEach(() => { options = Vue.options })
-  afterEach(() => { Vue.options = options })
-
-  it('should work', () => {
-    const spy = jasmine.createSpy('global mixin')
-    Vue.mixin({
-      created () {
-        spy(this.$options.myOption)
-      }
-    })
-    new Vue({
-      myOption: 'hello'
-    })
-    expect(spy).toHaveBeenCalledWith('hello')
-  })
-
-  it('should work for constructors created before mixin is applied', () => {
-    const calls = []
-    const Test = Vue.extend({
-      name: 'test',
-      beforeCreate () {
-        calls.push(this.$options.myOption + ' local')
-      }
-    })
-    Vue.mixin({
-      beforeCreate () {
-        calls.push(this.$options.myOption + ' global')
-      }
-    })
-    expect(Test.options.name).toBe('test')
-    new Test({
-      myOption: 'hello'
-    })
-    expect(calls).toEqual(['hello global', 'hello local'])
-  })
-
-  // #3957
-  it('should work for global props', () => {
-    const Test = Vue.extend({
-      template: `<div>{{ prop }}</div>`
-    })
-
-    Vue.mixin({
-      props: ['prop']
-    })
-
-    // test child component
-    const vm = new Vue({
-      template: '<test prop="hi"></test>',
-      components: { Test }
-    }).$mount()
-
-    expect(vm.$el.textContent).toBe('hi')
-  })
-
-  // vue-loader#433
-  it('should not drop late-set render functions', () => {
-    const Test = Vue.extend({})
-    Test.options.render = h => h('div', 'hello')
-
-    Vue.mixin({})
-
-    const vm = new Vue({
-      render: h => h(Test)
-    }).$mount()
-
-    expect(vm.$el.textContent).toBe('hello')
-  })
-
-  // #4266
-  it('should not drop scopedId', () => {
-    const Test = Vue.extend({})
-    Test.options._scopeId = 'foo'
-
-    Vue.mixin({})
-
-    const vm = new Test({
-      template: '<div><p>hi</p></div>'
-    }).$mount()
-
-    expect(vm.$el.children[0].hasAttribute('foo')).toBe(true)
-  })
-
-  // #4976
-  it('should not drop late-attached custom options on existing constructors', () => {
-    const baseSpy = jasmine.createSpy('base')
-    const Base = Vue.extend({
-      beforeCreate: baseSpy
-    })
-
-    const Test = Base.extend({})
-
-    // Inject options later
-    // vue-loader and vue-hot-reload-api are doing like this
-    Test.options.computed = {
-      $style: () => 123
-    }
-
-    const spy = jasmine.createSpy('late attached')
-    Test.options.beforeCreate = Test.options.beforeCreate.concat(spy)
-
-    // Update super constructor's options
-    const mixinSpy = jasmine.createSpy('mixin')
-    Vue.mixin({
-      beforeCreate: mixinSpy
-    })
-
-    // mount the component
-    const vm = new Test({
-      template: '<div>{{ $style }}</div>'
-    }).$mount()
-
-    expect(spy.calls.count()).toBe(1)
-    expect(baseSpy.calls.count()).toBe(1)
-    expect(mixinSpy.calls.count()).toBe(1)
-    expect(vm.$el.textContent).toBe('123')
-    expect(vm.$style).toBe(123)
-
-    // Should not be dropped
-    expect(Test.options.computed.$style()).toBe(123)
-    expect(Test.options.beforeCreate).toEqual([mixinSpy, baseSpy, spy])
-  })
-
-  // vue-class-component#83
-  it('should work for a constructor mixin', () => {
-    const spy = jasmine.createSpy('global mixin')
-    const Mixin = Vue.extend({
-      created () {
-        spy(this.$options.myOption)
-      }
-    })
-
-    Vue.mixin(Mixin)
-
-    new Vue({
-      myOption: 'hello'
-    })
-    expect(spy).toHaveBeenCalledWith('hello')
-  })
-
-  // vue-class-component#87
-  it('should not drop original lifecycle hooks', () => {
-    const base = jasmine.createSpy('base')
-
-    const Base = Vue.extend({
-      beforeCreate: base
-    })
-
-    const injected = jasmine.createSpy('injected')
-
-    // inject a function
-    Base.options.beforeCreate = Base.options.beforeCreate.concat(injected)
-
-    Vue.mixin({})
-
-    new Base({})
-
-    expect(base).toHaveBeenCalled()
-    expect(injected).toHaveBeenCalled()
-  })
-
-  // #8595
-  it('chain call', () => {
-    expect(Vue.mixin({})).toBe(Vue)
-  })
-
-  // #9198
-  it('should not mix global mixin lifecycle hook twice', () => {
-    const spy = jasmine.createSpy('global mixed in lifecycle hook')
-    Vue.mixin({
-      created: spy
-    })
-
-    const mixin1 = Vue.extend({
-      methods: {
-        a() {}
-      }
-    })
-
-    const mixin2 = Vue.extend({
-      mixins: [mixin1]
-    })
-
-    const Child = Vue.extend({
-      mixins: [mixin2],
-    })
-
-    const vm = new Child()
-
-    expect(typeof vm.$options.methods.a).toBe('function')
-    expect(spy.calls.count()).toBe(1)
-  })
-})
diff --git a/1.Vue/test/unit/features/global-api/observable.spec.js b/1.Vue/test/unit/features/global-api/observable.spec.js
deleted file mode 100644
index ecf2897..0000000
--- a/1.Vue/test/unit/features/global-api/observable.spec.js
+++ /dev/null
@@ -1,30 +0,0 @@
-import Vue from 'vue'
-
-describe('Global API: observable', () => {
-  it('should work', done => {
-    const state = Vue.observable({
-      count: 0
-    })
-
-    const app = new Vue({
-      render(h) {
-        return h('div', [
-          h('span', state.count),
-          h('button', {
-            on: {
-              click: () => {
-                state.count++
-              }
-            }
-          }, '+')
-        ])
-      }
-    }).$mount()
-
-    expect(app.$el.querySelector('span').textContent).toBe('0')
-    app.$el.querySelector('button').click()
-    waitForUpdate(() => {
-      expect(app.$el.querySelector('span').textContent).toBe('1')
-    }).then(done)
-  })
-})
diff --git a/1.Vue/test/unit/features/global-api/set-delete.spec.js b/1.Vue/test/unit/features/global-api/set-delete.spec.js
deleted file mode 100644
index d1c7f3d..0000000
--- a/1.Vue/test/unit/features/global-api/set-delete.spec.js
+++ /dev/null
@@ -1,170 +0,0 @@
-import Vue from 'vue'
-
-describe('Global API: set/delete', () => {
-  describe('Vue.set', () => {
-    it('should update a vue object', done => {
-      const vm = new Vue({
-        template: '<div>{{x}}</div>',
-        data: { x: 1 }
-      }).$mount()
-      expect(vm.$el.innerHTML).toBe('1')
-      Vue.set(vm, 'x', 2)
-      waitForUpdate(() => {
-        expect(vm.$el.innerHTML).toBe('2')
-      }).then(done)
-    })
-
-    it('should update a observing object', done => {
-      const vm = new Vue({
-        template: '<div>{{foo.x}}</div>',
-        data: { foo: { x: 1 }}
-      }).$mount()
-      expect(vm.$el.innerHTML).toBe('1')
-      Vue.set(vm.foo, 'x', 2)
-      waitForUpdate(() => {
-        expect(vm.$el.innerHTML).toBe('2')
-      }).then(done)
-    })
-
-    it('should update a observing array', done => {
-      const vm = new Vue({
-        template: '<div><div v-for="v,k in list">{{k}}-{{v}}</div></div>',
-        data: { list: ['a', 'b', 'c'] }
-      }).$mount()
-      expect(vm.$el.innerHTML).toBe('<div>0-a</div><div>1-b</div><div>2-c</div>')
-      Vue.set(vm.list, 1, 'd')
-      waitForUpdate(() => {
-        expect(vm.$el.innerHTML).toBe('<div>0-a</div><div>1-d</div><div>2-c</div>')
-        Vue.set(vm.list, '2', 'e')
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe('<div>0-a</div><div>1-d</div><div>2-e</div>')
-        /* eslint-disable no-new-wrappers */
-        Vue.set(vm.list, new Number(1), 'f')
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe('<div>0-a</div><div>1-f</div><div>2-e</div>')
-        Vue.set(vm.list, '3g', 'g')
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe('<div>0-a</div><div>1-f</div><div>2-e</div>')
-      }).then(done)
-    })
-
-    it('should update a vue object with nothing', done => {
-      const vm = new Vue({
-        template: '<div>{{x}}</div>',
-        data: { x: 1 }
-      }).$mount()
-      expect(vm.$el.innerHTML).toBe('1')
-      Vue.set(vm, 'x', null)
-      waitForUpdate(() => {
-        expect(vm.$el.innerHTML).toBe('')
-        Vue.set(vm, 'x')
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe('')
-      }).then(done)
-    })
-
-    it('be able to use string type index in array', done => {
-      const vm = new Vue({
-        template: '<div><p v-for="obj in lists">{{obj.name}}</p></div>',
-        data: {
-          lists: [
-            { name: 'A' },
-            { name: 'B' },
-            { name: 'C' }
-          ]
-        }
-      }).$mount()
-      expect(vm.$el.innerHTML).toBe('<p>A</p><p>B</p><p>C</p>')
-      Vue.set(vm.lists, '0', { name: 'D' })
-      waitForUpdate(() => {
-        expect(vm.$el.innerHTML).toBe('<p>D</p><p>B</p><p>C</p>')
-      }).then(done)
-    })
-
-    // #6845
-    it('should not overwrite properties on prototype chain', () => {
-      class Model {
-        constructor () {
-          this._bar = null
-        }
-        get bar () {
-          return this._bar
-        }
-        set bar (newvalue) {
-          this._bar = newvalue
-        }
-      }
-
-      const vm = new Vue({
-        data: {
-          data: new Model()
-        }
-      })
-
-      Vue.set(vm.data, 'bar', 123)
-      expect(vm.data.bar).toBe(123)
-      expect(vm.data.hasOwnProperty('bar')).toBe(false)
-      expect(vm.data._bar).toBe(123)
-    })
-  })
-
-  describe('Vue.delete', () => {
-    it('should delete a key', done => {
-      const vm = new Vue({
-        template: '<div>{{obj.x}}</div>',
-        data: { obj: { x: 1 }}
-      }).$mount()
-      expect(vm.$el.innerHTML).toBe('1')
-      vm.obj.x = 2
-      waitForUpdate(() => {
-        expect(vm.$el.innerHTML).toBe('2')
-        Vue.delete(vm.obj, 'x')
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe('')
-        vm.obj.x = 3
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe('')
-      }).then(done)
-    })
-
-    it('be able to delete an item in array', done => {
-      const vm = new Vue({
-        template: '<div><p v-for="obj in lists">{{obj.name}}</p></div>',
-        data: {
-          lists: [
-            { name: 'A' },
-            { name: 'B' },
-            { name: 'C' }
-          ]
-        }
-      }).$mount()
-      expect(vm.$el.innerHTML).toBe('<p>A</p><p>B</p><p>C</p>')
-      Vue.delete(vm.lists, 1)
-      waitForUpdate(() => {
-        expect(vm.$el.innerHTML).toBe('<p>A</p><p>C</p>')
-        Vue.delete(vm.lists, NaN)
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe('<p>A</p><p>C</p>')
-        Vue.delete(vm.lists, -1)
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe('<p>A</p><p>C</p>')
-        Vue.delete(vm.lists, '1.3')
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe('<p>A</p><p>C</p>')
-        Vue.delete(vm.lists, true)
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe('<p>A</p><p>C</p>')
-        Vue.delete(vm.lists, {})
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe('<p>A</p><p>C</p>')
-        Vue.delete(vm.lists, '1')
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe('<p>A</p>')
-        /* eslint-disable no-new-wrappers */
-        Vue.delete(vm.lists, new Number(0))
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe('')
-      }).then(done)
-    })
-  })
-})
diff --git a/1.Vue/test/unit/features/global-api/use.spec.js b/1.Vue/test/unit/features/global-api/use.spec.js
deleted file mode 100644
index d54ff07..0000000
--- a/1.Vue/test/unit/features/global-api/use.spec.js
+++ /dev/null
@@ -1,57 +0,0 @@
-import Vue from 'vue'
-
-describe('Global API: use', () => {
-  const def = {}
-  const options = {}
-  const pluginStub = {
-    install: (Vue, opts) => {
-      Vue.directive('plugin-test', def)
-      expect(opts).toBe(options)
-    }
-  }
-
-  it('should apply Object plugin', () => {
-    Vue.use(pluginStub, options)
-    expect(Vue.options.directives['plugin-test']).toBe(def)
-    delete Vue.options.directives['plugin-test']
-    expect(Vue.options.directives['plugin-test']).toBeUndefined()
-
-    // should not double apply
-    Vue.use(pluginStub, options)
-    expect(Vue.options.directives['plugin-test']).toBeUndefined()
-  })
-
-  it('should apply Function plugin', () => {
-    Vue.use(pluginStub.install, options)
-    expect(Vue.options.directives['plugin-test']).toBe(def)
-    delete Vue.options.directives['plugin-test']
-  })
-
-  it('should work on extended constructors without polluting the base', () => {
-    const Ctor = Vue.extend({})
-    Ctor.use(pluginStub, options)
-    expect(Vue.options.directives['plugin-test']).toBeUndefined()
-    expect(Ctor.options.directives['plugin-test']).toBe(def)
-  })
-
-  // GitHub issue #5970
-  it('should work on multi version', () => {
-    const Ctor1 = Vue.extend({})
-    const Ctor2 = Vue.extend({})
-
-    Ctor1.use(pluginStub, options)
-    expect(Vue.options.directives['plugin-test']).toBeUndefined()
-    expect(Ctor1.options.directives['plugin-test']).toBe(def)
-
-    // multi version Vue Ctor with the same cid
-    Ctor2.cid = Ctor1.cid
-    Ctor2.use(pluginStub, options)
-    expect(Vue.options.directives['plugin-test']).toBeUndefined()
-    expect(Ctor2.options.directives['plugin-test']).toBe(def)
-  })
-
-  // #8595
-  it('chain call', () => {
-    expect(Vue.use(() => {})).toBe(Vue)
-  })
-})
diff --git a/1.Vue/test/unit/features/instance/init.spec.js b/1.Vue/test/unit/features/instance/init.spec.js
deleted file mode 100644
index 62cc06d..0000000
--- a/1.Vue/test/unit/features/instance/init.spec.js
+++ /dev/null
@@ -1,12 +0,0 @@
-import Vue from 'vue'
-
-describe('Initialization', () => {
-  it('without new', () => {
-    try { Vue() } catch (e) {}
-    expect('Vue is a constructor and should be called with the `new` keyword').toHaveBeenWarned()
-  })
-
-  it('with new', () => {
-    expect(new Vue() instanceof Vue).toBe(true)
-  })
-})
diff --git a/1.Vue/test/unit/features/instance/methods-data.spec.js b/1.Vue/test/unit/features/instance/methods-data.spec.js
deleted file mode 100644
index 6405039..0000000
--- a/1.Vue/test/unit/features/instance/methods-data.spec.js
+++ /dev/null
@@ -1,128 +0,0 @@
-import Vue from 'vue'
-
-describe('Instance methods data', () => {
-  it('$set/$delete', done => {
-    const vm = new Vue({
-      template: '<div>{{ a.msg }}</div>',
-      data: {
-        a: {}
-      }
-    }).$mount()
-    expect(vm.$el.innerHTML).toBe('')
-    vm.$set(vm.a, 'msg', 'hello')
-    waitForUpdate(() => {
-      expect(vm.$el.innerHTML).toBe('hello')
-      vm.$delete(vm.a, 'msg')
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('')
-    }).then(done)
-  })
-
-  describe('$watch', () => {
-    let vm, spy
-    beforeEach(() => {
-      spy = jasmine.createSpy('watch')
-      vm = new Vue({
-        data: {
-          a: {
-            b: 1
-          },
-          유니코드: {
-            なまえ: 'ok'
-          }
-        },
-        methods: {
-          foo: spy
-        }
-      })
-    })
-
-    it('basic usage', done => {
-      vm.$watch('a.b', spy)
-      vm.a.b = 2
-      waitForUpdate(() => {
-        expect(spy.calls.count()).toBe(1)
-        expect(spy).toHaveBeenCalledWith(2, 1)
-        vm.a = { b: 3 }
-      }).then(() => {
-        expect(spy.calls.count()).toBe(2)
-        expect(spy).toHaveBeenCalledWith(3, 2)
-      }).then(done)
-    })
-
-    it('immediate', () => {
-      vm.$watch('a.b', spy, { immediate: true })
-      expect(spy.calls.count()).toBe(1)
-      expect(spy).toHaveBeenCalledWith(1)
-    })
-
-    it('unwatch', done => {
-      const unwatch = vm.$watch('a.b', spy)
-      unwatch()
-      vm.a.b = 2
-      waitForUpdate(() => {
-        expect(spy.calls.count()).toBe(0)
-      }).then(done)
-    })
-
-    it('function watch', done => {
-      vm.$watch(function () {
-        return this.a.b
-      }, spy)
-      vm.a.b = 2
-      waitForUpdate(() => {
-        expect(spy).toHaveBeenCalledWith(2, 1)
-      }).then(done)
-    })
-
-    it('deep watch', done => {
-      const oldA = vm.a
-      vm.$watch('a', spy, { deep: true })
-      vm.a.b = 2
-      waitForUpdate(() => {
-        expect(spy).toHaveBeenCalledWith(oldA, oldA)
-        vm.a = { b: 3 }
-      }).then(() => {
-        expect(spy).toHaveBeenCalledWith(vm.a, oldA)
-      }).then(done)
-    })
-
-    it('handler option', done => {
-      const oldA = vm.a
-      vm.$watch('a', {
-        handler: spy,
-        deep: true
-      })
-      vm.a.b = 2
-      waitForUpdate(() => {
-        expect(spy).toHaveBeenCalledWith(oldA, oldA)
-        vm.a = { b: 3 }
-      }).then(() => {
-        expect(spy).toHaveBeenCalledWith(vm.a, oldA)
-      }).then(done)
-    })
-
-    it('handler option in string', () => {
-      vm.$watch('a.b', {
-        handler: 'foo',
-        immediate: true
-      })
-      expect(spy.calls.count()).toBe(1)
-      expect(spy).toHaveBeenCalledWith(1)
-    })
-
-    it('handler option in string', () => {
-      vm.$watch('유니코드.なまえ', {
-        handler: 'foo',
-        immediate: true
-      })
-      expect(spy.calls.count()).toBe(1)
-      expect(spy).toHaveBeenCalledWith('ok')
-    })
-
-    it('warn expression', () => {
-      vm.$watch('a + b', spy)
-      expect('Watcher only accepts simple dot-delimited paths').toHaveBeenWarned()
-    })
-  })
-})
diff --git a/1.Vue/test/unit/features/instance/methods-events.spec.js b/1.Vue/test/unit/features/instance/methods-events.spec.js
deleted file mode 100644
index 47d15bd..0000000
--- a/1.Vue/test/unit/features/instance/methods-events.spec.js
+++ /dev/null
@@ -1,96 +0,0 @@
-import Vue from 'vue'
-
-describe('Instance methods events', () => {
-  let vm, spy
-  beforeEach(() => {
-    vm = new Vue()
-    spy = jasmine.createSpy('emitter')
-  })
-
-  it('$on', () => {
-    vm.$on('test', function () {
-      // expect correct context
-      expect(this).toBe(vm)
-      spy.apply(this, arguments)
-    })
-    vm.$emit('test', 1, 2, 3, 4)
-    expect(spy.calls.count()).toBe(1)
-    expect(spy).toHaveBeenCalledWith(1, 2, 3, 4)
-  })
-
-  it('$on multi event', () => {
-    vm.$on(['test1', 'test2'], function () {
-      expect(this).toBe(vm)
-      spy.apply(this, arguments)
-    })
-    vm.$emit('test1', 1, 2, 3, 4)
-    expect(spy.calls.count()).toBe(1)
-    expect(spy).toHaveBeenCalledWith(1, 2, 3, 4)
-    vm.$emit('test2', 5, 6, 7, 8)
-    expect(spy.calls.count()).toBe(2)
-    expect(spy).toHaveBeenCalledWith(5, 6, 7, 8)
-  })
-
-  it('$off multi event', () => {
-    vm.$on(['test1', 'test2', 'test3'], spy)
-    vm.$off(['test1', 'test2'], spy)
-    vm.$emit('test1')
-    vm.$emit('test2')
-    expect(spy).not.toHaveBeenCalled()
-    vm.$emit('test3', 1, 2, 3, 4)
-    expect(spy.calls.count()).toBe(1)
-  })
-
-  it('$off multi event without callback', () => {
-    vm.$on(['test1', 'test2'], spy)
-    vm.$off(['test1', 'test2'])
-    vm.$emit('test1')
-    expect(spy).not.toHaveBeenCalled()
-  })
-
-  it('$once', () => {
-    vm.$once('test', spy)
-    vm.$emit('test', 1, 2, 3)
-    vm.$emit('test', 2, 3, 4)
-    expect(spy.calls.count()).toBe(1)
-    expect(spy).toHaveBeenCalledWith(1, 2, 3)
-  })
-
-  it('$off event added by $once', () => {
-    vm.$once('test', spy)
-    vm.$off('test', spy) // test off event and this event added by once
-    vm.$emit('test', 1, 2, 3)
-    expect(spy).not.toHaveBeenCalled()
-  })
-
-  it('$off', () => {
-    vm.$on('test1', spy)
-    vm.$on('test2', spy)
-    vm.$off()
-    vm.$emit('test1')
-    vm.$emit('test2')
-    expect(spy).not.toHaveBeenCalled()
-  })
-
-  it('$off event', () => {
-    vm.$on('test1', spy)
-    vm.$on('test2', spy)
-    vm.$off('test1')
-    vm.$off('test1') // test off something that's already off
-    vm.$emit('test1', 1)
-    vm.$emit('test2', 2)
-    expect(spy.calls.count()).toBe(1)
-    expect(spy).toHaveBeenCalledWith(2)
-  })
-
-  it('$off event + fn', () => {
-    const spy2 = jasmine.createSpy('emitter')
-    vm.$on('test', spy)
-    vm.$on('test', spy2)
-    vm.$off('test', spy)
-    vm.$emit('test', 1, 2, 3)
-    expect(spy).not.toHaveBeenCalled()
-    expect(spy2.calls.count()).toBe(1)
-    expect(spy2).toHaveBeenCalledWith(1, 2, 3)
-  })
-})
diff --git a/1.Vue/test/unit/features/instance/methods-lifecycle.spec.js b/1.Vue/test/unit/features/instance/methods-lifecycle.spec.js
deleted file mode 100644
index 1e424a5..0000000
--- a/1.Vue/test/unit/features/instance/methods-lifecycle.spec.js
+++ /dev/null
@@ -1,151 +0,0 @@
-import Vue from 'vue'
-import Dep from 'core/observer/dep'
-
-describe('Instance methods lifecycle', () => {
-  describe('$mount', () => {
-    it('empty mount', () => {
-      const vm = new Vue({
-        data: { msg: 'hi' },
-        template: '<div>{{ msg }}</div>'
-      }).$mount()
-      expect(vm.$el.tagName).toBe('DIV')
-      expect(vm.$el.textContent).toBe('hi')
-    })
-
-    it('mount to existing element', () => {
-      const el = document.createElement('div')
-      el.innerHTML = '{{ msg }}'
-      const vm = new Vue({
-        data: { msg: 'hi' }
-      }).$mount(el)
-      expect(vm.$el.tagName).toBe('DIV')
-      expect(vm.$el.textContent).toBe('hi')
-    })
-
-    it('mount to id', () => {
-      const el = document.createElement('div')
-      el.id = 'mount-test'
-      el.innerHTML = '{{ msg }}'
-      document.body.appendChild(el)
-      const vm = new Vue({
-        data: { msg: 'hi' }
-      }).$mount('#mount-test')
-      expect(vm.$el.tagName).toBe('DIV')
-      expect(vm.$el.textContent).toBe('hi')
-    })
-
-    it('Dep.target should be undefined in lifecycle', () => {
-      const vm = new Vue({
-        template: '<div><my-component></my-component></div>',
-        components: {
-          myComponent: {
-            template: '<div>hi</div>',
-            mounted () {
-              const _msg = this.msg
-              expect(Dep.target).toBe(undefined)
-            },
-            computed: {
-              msg () {
-                return 1
-              }
-            }
-          }
-        }
-      }).$mount()
-    })
-  })
-
-  describe('$destroy', () => {
-    it('remove self from parent', () => {
-      const vm = new Vue({
-        template: '<test></test>',
-        components: {
-          test: { template: '<div></div>' }
-        }
-      }).$mount()
-      vm.$children[0].$destroy()
-      expect(vm.$children.length).toBe(0)
-    })
-
-    it('teardown watchers', () => {
-      const vm = new Vue({
-        data: { a: 123 },
-        template: '<div></div>'
-      }).$mount()
-      vm.$watch('a', () => {})
-      vm.$destroy()
-      expect(vm._watcher.active).toBe(false)
-      expect(vm._watchers.every(w => !w.active)).toBe(true)
-    })
-
-    it('remove self from data observer', () => {
-      const vm = new Vue({ data: { a: 1 }})
-      vm.$destroy()
-      expect(vm.$data.__ob__.vmCount).toBe(0)
-    })
-
-    it('avoid duplicate calls', () => {
-      const spy = jasmine.createSpy('destroy')
-      const vm = new Vue({
-        beforeDestroy: spy
-      })
-      vm.$destroy()
-      vm.$destroy()
-      expect(spy.calls.count()).toBe(1)
-    })
-  })
-
-  describe('$forceUpdate', () => {
-    it('should force update', done => {
-      const vm = new Vue({
-        data: {
-          a: {}
-        },
-        template: '<div>{{ a.b }}</div>'
-      }).$mount()
-      expect(vm.$el.textContent).toBe('')
-      vm.a.b = 'foo'
-      waitForUpdate(() => {
-        // should not work because adding new property
-        expect(vm.$el.textContent).toBe('')
-        vm.$forceUpdate()
-      }).then(() => {
-        expect(vm.$el.textContent).toBe('foo')
-      }).then(done)
-    })
-  })
-
-  describe('$nextTick', () => {
-    it('should be called after DOM update in correct context', done => {
-      const vm = new Vue({
-        template: '<div>{{ msg }}</div>',
-        data: {
-          msg: 'foo'
-        }
-      }).$mount()
-      vm.msg = 'bar'
-      vm.$nextTick(function () {
-        expect(this).toBe(vm)
-        expect(vm.$el.textContent).toBe('bar')
-        done()
-      })
-    })
-
-    if (typeof Promise !== 'undefined') {
-      it('should be called after DOM update in correct context, when using Promise syntax', done => {
-        const vm = new Vue({
-          template: '<div>{{ msg }}</div>',
-          data: {
-            msg: 'foo'
-          }
-        }).$mount()
-        vm.msg = 'bar'
-        vm.$nextTick().then(ctx => {
-          expect(ctx).toBe(vm)
-          expect(vm.$el.textContent).toBe('bar')
-          done()
-        })
-      })
-    }
-  })
-})
diff --git a/1.Vue/test/unit/features/instance/properties.spec.js b/1.Vue/test/unit/features/instance/properties.spec.js
deleted file mode 100644
index abe1cc6..0000000
--- a/1.Vue/test/unit/features/instance/properties.spec.js
+++ /dev/null
@@ -1,203 +0,0 @@
-import Vue from 'vue'
-
-describe('Instance properties', () => {
-  it('$data', () => {
-    const data = { a: 1 }
-    const vm = new Vue({
-      data
-    })
-    expect(vm.a).toBe(1)
-    expect(vm.$data).toBe(data)
-    // vm -> data
-    vm.a = 2
-    expect(data.a).toBe(2)
-    // data -> vm
-    data.a = 3
-    expect(vm.a).toBe(3)
-  })
-
-  it('$options', () => {
-    const A = Vue.extend({
-      methods: {
-        a () {}
-      }
-    })
-    const vm = new A({
-      methods: {
-        b () {}
-      }
-    })
-    expect(typeof vm.$options.methods.a).toBe('function')
-    expect(typeof vm.$options.methods.b).toBe('function')
-  })
-
-  it('$root/$children', done => {
-    const vm = new Vue({
-      template: '<div><test v-if="ok"></test></div>',
-      data: { ok: true },
-      components: {
-        test: {
-          template: '<div></div>'
-        }
-      }
-    }).$mount()
-    expect(vm.$root).toBe(vm)
-    expect(vm.$children.length).toBe(1)
-    expect(vm.$children[0].$root).toBe(vm)
-    vm.ok = false
-    waitForUpdate(() => {
-      expect(vm.$children.length).toBe(0)
-      vm.ok = true
-    }).then(() => {
-      expect(vm.$children.length).toBe(1)
-      expect(vm.$children[0].$root).toBe(vm)
-    }).then(done)
-  })
-
-  it('$parent', () => {
-    const calls = []
-    const makeOption = name => ({
-      name,
-      template: `<div><slot></slot></div>`,
-      created () {
-        calls.push(`${name}:${this.$parent.$options.name}`)
-      }
-    })
-    new Vue({
-      template: `
-        <div>
-          <outer><middle><inner></inner></middle></outer>
-          <next></next>
-        </div>
-      `,
-      components: {
-        outer: makeOption('outer'),
-        middle: makeOption('middle'),
-        inner: makeOption('inner'),
-        next: makeOption('next')
-      }
-    }).$mount()
-    expect(calls).toEqual(['outer:undefined', 'middle:outer', 'inner:middle', 'next:undefined'])
-  })
-
-  it('$props', done => {
-    const Comp = Vue.extend({
-      props: ['msg'],
-      template: '<div>{{ msg }} {{ $props.msg }}</div>'
-    })
-    const vm = new Comp({
-      propsData: {
-        msg: 'foo'
-      }
-    }).$mount()
-    // check render
-    expect(vm.$el.textContent).toContain('foo foo')
-    // warn set
-    vm.$props = {}
-    expect('$props is readonly').toHaveBeenWarned()
-    // check existence
-    expect(vm.$props.msg).toBe('foo')
-    // check change
-    vm.msg = 'bar'
-    expect(vm.$props.msg).toBe('bar')
-    waitForUpdate(() => {
-      expect(vm.$el.textContent).toContain('bar bar')
-    }).then(() => {
-      vm.$props.msg = 'baz'
-      expect(vm.msg).toBe('baz')
-    }).then(() => {
-      expect(vm.$el.textContent).toContain('baz baz')
-    }).then(done)
-  })
-
-  it('warn mutating $props', () => {
-    const Comp = {
-      props: ['msg'],
-      render () {},
-      mounted () {
-        expect(this.$props.msg).toBe('foo')
-        this.$props.msg = 'bar'
-      }
-    }
-    new Vue({
-      template: `<comp ref="comp" msg="foo" />`,
-      components: { Comp }
-    }).$mount()
-    expect(`Avoid mutating a prop`).toHaveBeenWarned()
-  })
-
-  it('$attrs', done => {
-    const vm = new Vue({
-      template: `<foo :id="foo" bar="1"/>`,
-      data: { foo: 'foo' },
-      components: {
-        foo: {
-          props: ['bar'],
-          template: `<div><div v-bind="$attrs"></div></div>`
-        }
-      }
-    }).$mount()
-    expect(vm.$el.children[0].id).toBe('foo')
-    expect(vm.$el.children[0].hasAttribute('bar')).toBe(false)
-    vm.foo = 'bar'
-    waitForUpdate(() => {
-      expect(vm.$el.children[0].id).toBe('bar')
-      expect(vm.$el.children[0].hasAttribute('bar')).toBe(false)
-    }).then(done)
-  })
-
-  // #6263
-  it('$attrs should not be undefined when no props passed in', () => {
-    const vm = new Vue({
-      template: `<foo ref="foo" />`,
-      data: { foo: 'foo' },
-      components: {
-        foo: {
-          template: `<div>foo</div>`
-        }
-      }
-    }).$mount()
-    expect(vm.$refs.foo.$attrs).toBeDefined()
-  })
-
-  it('warn mutating $attrs', () => {
-    const vm = new Vue()
-    vm.$attrs = {}
-    expect(`$attrs is readonly`).toHaveBeenWarned()
-  })
-
-  it('$listeners', done => {
-    const spyA = jasmine.createSpy('A')
-    const spyB = jasmine.createSpy('B')
-    const vm = new Vue({
-      template: `<foo @click="foo"/>`,
-      data: { foo: spyA },
-      components: {
-        foo: {
-          template: `<div v-on="$listeners"></div>`
-        }
-      }
-    }).$mount()
-
-    // has to be in dom for test to pass in IE
-    document.body.appendChild(vm.$el)
-
-    triggerEvent(vm.$el, 'click')
-    expect(spyA.calls.count()).toBe(1)
-    expect(spyB.calls.count()).toBe(0)
-
-    vm.foo = spyB
-    waitForUpdate(() => {
-      triggerEvent(vm.$el, 'click')
-      expect(spyA.calls.count()).toBe(1)
-      expect(spyB.calls.count()).toBe(1)
-      document.body.removeChild(vm.$el)
-    }).then(done)
-  })
-
-  it('warn mutating $listeners', () => {
-    const vm = new Vue()
-    vm.$listeners = {}
-    expect(`$listeners is readonly`).toHaveBeenWarned()
-  })
-})
diff --git a/1.Vue/test/unit/features/instance/render-proxy.spec.js b/1.Vue/test/unit/features/instance/render-proxy.spec.js
deleted file mode 100644
index 8da1717..0000000
--- a/1.Vue/test/unit/features/instance/render-proxy.spec.js
+++ /dev/null
@@ -1,93 +0,0 @@
-import Vue from 'vue'
-
-if (typeof Proxy !== 'undefined') {
-  describe('render proxy', () => {
-    it('should warn missing property in render fns with `with`', () => {
-      new Vue({
-        template: `<div>{{ a }}</div>`
-      }).$mount()
-      expect(`Property or method "a" is not defined`).toHaveBeenWarned()
-    })
-
-    it('should warn missing property in render fns without `with`', () => {
-      const render = function (h) {
-        return h('div', [this.a])
-      }
-      render._withStripped = true
-      new Vue({
-        render
-      }).$mount()
-      expect(`Property or method "a" is not defined`).toHaveBeenWarned()
-    })
-
-    it('should not warn for hand-written render functions', () => {
-      new Vue({
-        render (h) {
-          return h('div', [this.a])
-        }
-      }).$mount()
-      expect(`Property or method "a" is not defined`).not.toHaveBeenWarned()
-    })
-
-    it('support symbols using the `in` operator in hand-written render functions', () => {
-      const sym = Symbol()
-
-      const vm = new Vue({
-        created () {
-          this[sym] = 'foo'
-        },
-        render (h) {
-          if (sym in this) {
-            return h('div', [this[sym]])
-          }
-        }
-      }).$mount()
-
-      expect(vm.$el.textContent).toBe('foo')
-    })
-
-    it('should warn properties starting with $ when found', () => {
-      new Vue({
-        data: { $a: 'foo' },
-        template: `<div>{{ $a }}</div>`
-      }).$mount()
-      expect(`Property "$a" must be accessed with "$data.$a"`).toHaveBeenWarned()
-    })
-
-    it('should warn properties starting with _ when found', () => {
-      new Vue({
-        data: { _foo: 'foo' },
-        template: `<div>{{ _foo }}</div>`
-      }).$mount()
-      expect(`Property "_foo" must be accessed with "$data._foo"`).toHaveBeenWarned()
-    })
-
-    it('should warn properties starting with $ when not found', () => {
-      new Vue({
-        template: `<div>{{ $a }}</div>`
-      }).$mount()
-      expect(`Property or method "$a" is not defined`).toHaveBeenWarned()
-      expect(`Property "$a" must be accessed with "$data.$a"`).not.toHaveBeenWarned()
-    })
-
-    it('should warn properties starting with $ when not found (with stripped)', () => {
-      const render = function (h) {
-        return h('p', this.$a)
-      }
-      render._withStripped = true
-      new Vue({
-        data: { $a: 'foo' },
-        render
-      }).$mount()
-      expect(`Property "$a" must be accessed with "$data.$a"`).toHaveBeenWarned()
-    })
-
-    it('should not warn properties starting with $ when using $data to access', () => {
-      new Vue({
-        data: { $a: 'foo' },
-        template: `<div>{{ $data.$a }}</div>`
-      }).$mount()
-      expect(`Property or method "$a" is not defined`).not.toHaveBeenWarned()
-    })
-  })
-}
diff --git a/1.Vue/test/unit/features/options/_scopeId.spec.js b/1.Vue/test/unit/features/options/_scopeId.spec.js
deleted file mode 100644
index ec45f90..0000000
--- a/1.Vue/test/unit/features/options/_scopeId.spec.js
+++ /dev/null
@@ -1,96 +0,0 @@
-import Vue from 'vue'
-
-describe('Options _scopeId', () => {
-  it('should add scopeId attributes', () => {
-    const vm = new Vue({
-      _scopeId: 'foo',
-      template: '<div><p><span></span></p></div>'
-    }).$mount()
-    expect(vm.$el.hasAttribute('foo')).toBe(true)
-    expect(vm.$el.children[0].hasAttribute('foo')).toBe(true)
-    expect(vm.$el.children[0].children[0].hasAttribute('foo')).toBe(true)
-  })
-
-  it('should add scopedId attributes from both parent and child on child root', () => {
-    const vm = new Vue({
-      _scopeId: 'foo',
-      template: '<div><child></child></div>',
-      components: {
-        child: {
-          _scopeId: 'bar',
-          template: '<div></div>'
-        }
-      }
-    }).$mount()
-    expect(vm.$el.children[0].hasAttribute('foo')).toBe(true)
-    expect(vm.$el.children[0].hasAttribute('bar')).toBe(true)
-  })
-
-  it('should add scopedId attributes from both parent and child on slot contents', () => {
-    const vm = new Vue({
-      _scopeId: 'foo',
-      template: '<div><child><p>hi</p></child></div>',
-      components: {
-        child: {
-          _scopeId: 'bar',
-          template: '<div><slot></slot></div>'
-        }
-      }
-    }).$mount()
-    expect(vm.$el.children[0].children[0].hasAttribute('foo')).toBe(true)
-    expect(vm.$el.children[0].children[0].hasAttribute('bar')).toBe(true)
-  })
-
-  // #4774
-  it('should not discard parent scopeId when component root element is replaced', done => {
-    const vm = new Vue({
-      _scopeId: 'data-1',
-      template: `<div><child ref="child" /></div>`,
-      components: {
-        child: {
-          _scopeId: 'data-2',
-          data: () => ({ show: true }),
-          template: '<div v-if="show"></div>'
-        }
-      }
-    }).$mount()
-
-    const child = vm.$refs.child
-
-    expect(child.$el.hasAttribute('data-1')).toBe(true)
-    expect(child.$el.hasAttribute('data-2')).toBe(true)
-
-    child.show = false
-    waitForUpdate(() => {
-      child.show = true
-    }).then(() => {
-      expect(child.$el.hasAttribute('data-1')).toBe(true)
-      expect(child.$el.hasAttribute('data-2')).toBe(true)
-    }).then(done)
-  })
-
-  it('should work on functional components', () => {
-    const child = {
-      functional: true,
-      _scopeId: 'child',
-      render (h) {
-        return h('div', { class: 'child' }, [
-          h('span', { class: 'child' }, 'child')
-        ])
-      }
-    }
-    const vm = new Vue({
-      _scopeId: 'parent',
-      components: { child },
-      template: '<div><child></child></div>'
-    }).$mount()
-
-    expect(vm.$el.hasAttribute('parent')).toBe(true)
-    const childEls = vm.$el.querySelectorAll('.child')
-    ;[].forEach.call(childEls, el => {
-      expect(el.hasAttribute('child')).toBe(true)
-      // functional component with scopeId will not inherit parent scopeId
-      expect(el.hasAttribute('parent')).toBe(false)
-    })
-  })
-})
diff --git a/1.Vue/test/unit/features/options/comments.spec.js b/1.Vue/test/unit/features/options/comments.spec.js
deleted file mode 100644
index b13b63a..0000000
--- a/1.Vue/test/unit/features/options/comments.spec.js
+++ /dev/null
@@ -1,16 +0,0 @@
-import Vue from 'vue'
-
-describe('Comments', () => {
-  it('comments should be kept', () => {
-    const vm = new Vue({
-      comments: true,
-      data () {
-        return {
-          foo: 1
-        }
-      },
-      template: '<div><span>node1</span><!--comment1-->{{foo}}<!--comment2--></div>'
-    }).$mount()
-    expect(vm.$el.innerHTML).toEqual('<span>node1</span><!--comment1-->1<!--comment2-->')
-  })
-})
diff --git a/1.Vue/test/unit/features/options/components.spec.js b/1.Vue/test/unit/features/options/components.spec.js
deleted file mode 100644
index 1a94380..0000000
--- a/1.Vue/test/unit/features/options/components.spec.js
+++ /dev/null
@@ -1,92 +0,0 @@
-import Vue from 'vue'
-import { UA } from 'core/util/env'
-import testObjectOption from '../../../helpers/test-object-option'
-
-describe('Options components', () => {
-  testObjectOption('components')
-
-  it('should accept plain object', () => {
-    const vm = new Vue({
-      template: '<test></test>',
-      components: {
-        test: {
-          template: '<div>hi</div>'
-        }
-      }
-    }).$mount()
-    expect(vm.$el.tagName).toBe('DIV')
-    expect(vm.$el.textContent).toBe('hi')
-  })
-
-  it('should accept extended constructor', () => {
-    const Test = Vue.extend({
-      template: '<div>hi</div>'
-    })
-    const vm = new Vue({
-      template: '<test></test>',
-      components: {
-        test: Test
-      }
-    }).$mount()
-    expect(vm.$el.tagName).toBe('DIV')
-    expect(vm.$el.textContent).toBe('hi')
-  })
-
-  it('should accept camelCase', () => {
-    const myComp = {
-      template: '<div>hi</div>'
-    }
-    const vm = new Vue({
-      template: '<my-comp></my-comp>',
-      components: {
-        myComp
-      }
-    }).$mount()
-    expect(vm.$el.tagName).toBe('DIV')
-    expect(vm.$el.textContent).toBe('hi')
-  })
-
-  it('should accept PascalCase', () => {
-    const MyComp = {
-      template: '<div>hi</div>'
-    }
-    const vm = new Vue({
-      template: '<my-comp></my-comp>',
-      components: {
-        MyComp
-      }
-    }).$mount()
-    expect(vm.$el.tagName).toBe('DIV')
-    expect(vm.$el.textContent).toBe('hi')
-  })
-
-  it('should warn native HTML elements', () => {
-    new Vue({
-      components: {
-        div: { template: '<div></div>' }
-      }
-    })
-    expect('Do not use built-in or reserved HTML elements as component').toHaveBeenWarned()
-  })
-
-  it('should warn built-in elements', () => {
-    new Vue({
-      components: {
-        component: { template: '<div></div>' }
-      }
-    })
-    expect('Do not use built-in or reserved HTML elements as component').toHaveBeenWarned()
-  })
-
-  // the HTMLUnknownElement check doesn't work in Android 4.2
-  // but since it doesn't support custom elements nor will any dev use it
-  // as their primary debugging browser, it doesn't really matter.
-  if (!(UA && /android 4\.2/.test(UA))) {
-    it('warn non-existent', () => {
-      new Vue({
-        template: '<test></test>'
-      }).$mount()
-      expect('Unknown custom element: <test>').toHaveBeenWarned()
-    })
-  }
-})
diff --git a/1.Vue/test/unit/features/options/computed.spec.js b/1.Vue/test/unit/features/options/computed.spec.js
deleted file mode 100644
index edc20ba..0000000
--- a/1.Vue/test/unit/features/options/computed.spec.js
+++ /dev/null
@@ -1,219 +0,0 @@
-import Vue from 'vue'
-import testObjectOption from '../../../helpers/test-object-option'
-
-describe('Options computed', () => {
-  testObjectOption('computed')
-
-  it('basic usage', done => {
-    const vm = new Vue({
-      template: '<div>{{ b }}</div>',
-      data: {
-        a: 1
-      },
-      computed: {
-        b () {
-          return this.a + 1
-        }
-      }
-    }).$mount()
-    expect(vm.b).toBe(2)
-    expect(vm.$el.textContent).toBe('2')
-    vm.a = 2
-    expect(vm.b).toBe(3)
-    waitForUpdate(() => {
-      expect(vm.$el.textContent).toBe('3')
-    }).then(done)
-  })
-
-  it('with setter', done => {
-    const vm = new Vue({
-      template: '<div>{{ b }}</div>',
-      data: {
-        a: 1
-      },
-      computed: {
-        b: {
-          get () { return this.a + 1 },
-          set (v) { this.a = v - 1 }
-        }
-      }
-    }).$mount()
-    expect(vm.b).toBe(2)
-    expect(vm.$el.textContent).toBe('2')
-    vm.a = 2
-    expect(vm.b).toBe(3)
-    waitForUpdate(() => {
-      expect(vm.$el.textContent).toBe('3')
-      vm.b = 1
-      expect(vm.a).toBe(0)
-    }).then(() => {
-      expect(vm.$el.textContent).toBe('1')
-    }).then(done)
-  })
-
-  it('warn with setter and no getter', () => {
-    const vm = new Vue({
-      template: `
-        <div>
-          <test></test>
-        </div>
-      `,
-      components: {
-        test: {
-          data () {
-            return {
-              a: 1
-            }
-          },
-          computed: {
-            b: {
-              set (v) { this.a = v }
-            }
-          },
-          template: `<div>{{a}}</div>`
-        }
-      }
-    }).$mount()
-    expect(vm.$el.innerHTML).toBe('<div>1</div>')
-    expect('Getter is missing for computed property "b".').toHaveBeenWarned()
-  })
-
-  it('warn assigning to computed with no setter', () => {
-    const vm = new Vue({
-      computed: {
-        b () {
-          return 1
-        }
-      }
-    })
-    vm.b = 2
-    expect(`Computed property "b" was assigned to but it has no setter.`).toHaveBeenWarned()
-  })
-
-  it('watching computed', done => {
-    const spy = jasmine.createSpy('watch computed')
-    const vm = new Vue({
-      data: {
-        a: 1
-      },
-      computed: {
-        b () { return this.a + 1 }
-      }
-    })
-    vm.$watch('b', spy)
-    vm.a = 2
-    waitForUpdate(() => {
-      expect(spy).toHaveBeenCalledWith(3, 2)
-    }).then(done)
-  })
-
-  it('caching', () => {
-    const spy = jasmine.createSpy('cached computed')
-    const vm = new Vue({
-      data: {
-        a: 1
-      },
-      computed: {
-        b () {
-          spy()
-          return this.a + 1
-        }
-      }
-    })
-    expect(spy.calls.count()).toBe(0)
-    vm.b
-    expect(spy.calls.count()).toBe(1)
-    vm.b
-    expect(spy.calls.count()).toBe(1)
-  })
-
-  it('cache: false', () => {
-    const spy = jasmine.createSpy('cached computed')
-    const vm = new Vue({
-      data: {
-        a: 1
-      },
-      computed: {
-        b: {
-          cache: false,
-          get () {
-            spy()
-            return this.a + 1
-          }
-        }
-      }
-    })
-    expect(spy.calls.count()).toBe(0)
-    vm.b
-    expect(spy.calls.count()).toBe(1)
-    vm.b
-    expect(spy.calls.count()).toBe(2)
-  })
-
-  it('as component', done => {
-    const Comp = Vue.extend({
-      template: `<div>{{ b }} {{ c }}</div>`,
-      data () {
-        return { a: 1 }
-      },
-      computed: {
-        // defined on prototype
-        b () {
-          return this.a + 1
-        }
-      }
-    })
-
-    const vm = new Comp({
-      computed: {
-        // defined at instantiation
-        c () {
-          return this.b + 1
-        }
-      }
-    }).$mount()
-    expect(vm.b).toBe(2)
-    expect(vm.c).toBe(3)
-    expect(vm.$el.textContent).toBe('2 3')
-    vm.a = 2
-    expect(vm.b).toBe(3)
-    expect(vm.c).toBe(4)
-    waitForUpdate(() => {
-      expect(vm.$el.textContent).toBe('3 4')
-    }).then(done)
-  })
-
-  it('warn conflict with data', () => {
-    new Vue({
-      data: {
-        a: 1
-      },
-      computed: {
-        a: () => 2
-      }
-    })
-    expect(`computed property "a" is already defined in data`).toHaveBeenWarned()
-  })
-
-  it('warn conflict with props', () => {
-    new Vue({
-      props: ['a'],
-      propsData: { a: 1 },
-      computed: {
-        a: () => 2
-      }
-    })
-    expect(`computed property "a" is already defined as a prop`).toHaveBeenWarned()
-  })
-
-  it('rethrow computed error', () => {
-    const vm = new Vue({
-      computed: {
-        a: () => {
-          throw new Error('rethrow')
-        }
-      }
-    })
-    expect(() => vm.a).toThrowError('rethrow')
-  })
-})
diff --git a/1.Vue/test/unit/features/options/data.spec.js b/1.Vue/test/unit/features/options/data.spec.js
deleted file mode 100644
index ac431bb..0000000
--- a/1.Vue/test/unit/features/options/data.spec.js
+++ /dev/null
@@ -1,186 +0,0 @@
-import Vue from 'vue'
-
-describe('Options data', () => {
-  it('should proxy and be reactive', done => {
-    const data = { msg: 'foo' }
-    const vm = new Vue({
-      data,
-      template: '<div>{{ msg }}</div>'
-    }).$mount()
-    expect(vm.$data).toEqual({ msg: 'foo' })
-    expect(vm.$data).toBe(data)
-    data.msg = 'bar'
-    waitForUpdate(() => {
-      expect(vm.$el.textContent).toBe('bar')
-    }).then(done)
-  })
-
-  it('should merge data properly', () => {
-    const Test = Vue.extend({
-      data () {
-        return { a: 1 }
-      }
-    })
-    let vm = new Test({
-      data: { b: 2 }
-    })
-    expect(vm.a).toBe(1)
-    expect(vm.b).toBe(2)
-    // no instance data
-    vm = new Test()
-    expect(vm.a).toBe(1)
-    // no child-val
-    const Extended = Test.extend({})
-    vm = new Extended()
-    expect(vm.a).toBe(1)
-    // recursively merge objects
-    const WithObject = Vue.extend({
-      data () {
-        return {
-          obj: {
-            a: 1
-          }
-        }
-      }
-    })
-    vm = new WithObject({
-      data: {
-        obj: {
-          b: 2
-        }
-      }
-    })
-    expect(vm.obj.a).toBe(1)
-    expect(vm.obj.b).toBe(2)
-  })
-
-  it('should warn non-function during extend', () => {
-    Vue.extend({
-      data: { msg: 'foo' }
-    })
-    expect('The "data" option should be a function').toHaveBeenWarned()
-  })
-
-  it('should warn non object return', () => {
-    new Vue({
-      data () {}
-    })
-    expect('data functions should return an object').toHaveBeenWarned()
-  })
-
-  it('should warn replacing root $data', () => {
-    const vm = new Vue({
-      data: {}
-    })
-    vm.$data = {}
-    expect('Avoid replacing instance root $data').toHaveBeenWarned()
-  })
-
-  it('should have access to props', () => {
-    const Test = {
-      props: ['a'],
-      render () {},
-      data () {
-        return {
-          b: this.a
-        }
-      }
-    }
-    const vm = new Vue({
-      template: `<test ref="test" :a="1"></test>`,
-      components: { Test }
-    }).$mount()
-    expect(vm.$refs.test.b).toBe(1)
-  })
-
-  it('props should not be reactive', done => {
-    let calls = 0
-    const vm = new Vue({
-      template: `<child :msg="msg"></child>`,
-      data: {
-        msg: 'hello'
-      },
-      beforeUpdate () { calls++ },
-      components: {
-        child: {
-          template: `<span>{{ localMsg }}</span>`,
-          props: ['msg'],
-          data () {
-            return { localMsg: this.msg }
-          },
-          computed: {
-            computedMsg () {
-              return this.msg + ' world'
-            }
-          }
-        }
-      }
-    }).$mount()
-    const child = vm.$children[0]
-    vm.msg = 'hi'
-    waitForUpdate(() => {
-      expect(child.localMsg).toBe('hello')
-      expect(child.computedMsg).toBe('hi world')
-      expect(calls).toBe(1)
-    }).then(done)
-  })
-
-  it('should have access to methods', () => {
-    const vm = new Vue({
-      methods: {
-        get () {
-          return { a: 1 }
-        }
-      },
-      data () {
-        return this.get()
-      }
-    })
-    expect(vm.a).toBe(1)
-  })
-
-  it('should be called with this', () => {
-    const vm = new Vue({
-      template: '<div><child></child></div>',
-      provide: { foo: 1 },
-      components: {
-        child: {
-          template: '<span>{{bar}}</span>',
-          inject: ['foo'],
-          data ({ foo }) {
-            return { bar: 'foo:' + foo }
-          }
-        }
-      }
-    }).$mount()
-    expect(vm.$el.innerHTML).toBe('<span>foo:1</span>')
-  })
-
-  it('should be called with vm as first argument when merged', () => {
-    const superComponent = {
-      data: ({ foo }) => ({ ext: 'ext:' + foo })
-    }
-    const mixins = [
-      {
-        data: ({ foo }) => ({ mixin1: 'm1:' + foo })
-      },
-      {
-        data: ({ foo }) => ({ mixin2: 'm2:' + foo })
-      }
-    ]
-    const vm = new Vue({
-      template: '<div><child></child></div>',
-      provide: { foo: 1 },
-      components: {
-        child: {
-          extends: superComponent,
-          mixins,
-          template: '<span>{{bar}}-{{ext}}-{{mixin1}}-{{mixin2}}</span>',
-          inject: ['foo'],
-          data: ({ foo }) => ({ bar: 'foo:' + foo })
-        }
-      }
-    }).$mount()
-    expect(vm.$el.innerHTML).toBe('<span>foo:1-ext:1-m1:1-m2:1</span>')
-  })
-})
diff --git a/1.Vue/test/unit/features/options/delimiters.spec.js b/1.Vue/test/unit/features/options/delimiters.spec.js
deleted file mode 100644
index d477cab..0000000
--- a/1.Vue/test/unit/features/options/delimiters.spec.js
+++ /dev/null
@@ -1,116 +0,0 @@
-import Vue from 'vue'
-
-describe('Delimiters', () => {
-  it('default delimiters should work', () => {
-    const vm = new Vue({
-      data: {
-        a: 1
-      },
-      template: '<div>{{ a }}</div>'
-    }).$mount()
-    expect(vm.$el.textContent).toEqual('1')
-  })
-
-  it('custom delimiters should work', () => {
-    const vm = new Vue({
-      delimiters: ['[[', ']]'],
-      template: '<div>[[ a ]]</div>',
-      data: {
-        a: 1
-      }
-    }).$mount()
-
-    expect(vm.$el.textContent).toEqual('1')
-  })
-
-  it('default delimiters should be ignored when custom delimiters defined', () => {
-    const vm = new Vue({
-      delimiters: ['[[', ']]'],
-      template: '<div>{{ a }}</div>',
-      data: {
-        a: 1
-      }
-    }).$mount()
-
-    expect(vm.$el.textContent).toEqual('{{ a }}')
-  })
-
-  it('delimiters should only affect vm', () => {
-    const Component = Vue.extend({
-      data: function () {
-        return {
-          b: 2
-        }
-      },
-      template: '<span>[[ b ]]</span>'
-    })
-
-    const vm = new Vue({
-      delimiters: ['[[', ']]'],
-      template: '<div>[[ a ]] - <test-component></test-component></div>',
-      data: {
-        a: 2
-      },
-      components: {
-        'test-component': Component
-      }
-    }).$mount()
-
-    expect(vm.$el.textContent).toEqual('2 - [[ b ]]')
-  })
-
-  it('delimiters defined globally should work on all vms', () => {
-    Vue.options.delimiters = ['[[', ']]']
-
-    const Component = Vue.extend({
-      template: '<span>[[ a ]]</span>',
-      data: function () {
-        return {
-          a: 2
-        }
-      }
-    })
-
-    const vm = new Vue({
-      data: {
-        b: 1
-      },
-      template: '<div>[[ b ]] - <test-component></test-component></div>',
-      components: {
-        'test-component': Component
-      }
-    }).$mount()
-
-    expect(vm.$el.textContent).toEqual('1 - 2')
-    // restore default options
-    delete Vue.options.delimiters
-  })
-
-  it('component specific delimiters should override global delimiters', () => {
-    Vue.options.delimiters = ['[[', ']]']
-
-    const Component = Vue.extend({
-      delimiters: ['@{{', '}}'],
-      template: '<span>@{{ a }}</span>',
-      data: function () {
-        return {
-          a: 2
-        }
-      }
-    })
-
-    const vm = new Vue({
-      data: {
-        b: 1
-      },
-      template: '<div>[[ b ]] - <test-component></test-component></div>',
-      components: {
-        'test-component': Component
-      }
-    }).$mount()
-
-    expect(vm.$el.textContent).toEqual('1 - 2')
-    // restore default options
-    delete Vue.options.delimiters
-  })
-})
diff --git a/1.Vue/test/unit/features/options/directives.spec.js b/1.Vue/test/unit/features/options/directives.spec.js
deleted file mode 100644
index f7a6940..0000000
--- a/1.Vue/test/unit/features/options/directives.spec.js
+++ /dev/null
@@ -1,368 +0,0 @@
-import Vue from 'vue'
-
-describe('Options directives', () => {
-  it('basic usage', done => {
-    const bindSpy = jasmine.createSpy('bind')
-    const insertedSpy = jasmine.createSpy('inserted')
-    const updateSpy = jasmine.createSpy('update')
-    const componentUpdatedSpy = jasmine.createSpy('componentUpdated')
-    const unbindSpy = jasmine.createSpy('unbind')
-
-    const assertContext = (el, binding, vnode) => {
-      expect(vnode.context).toBe(vm)
-      expect(binding.arg).toBe('arg')
-      expect(binding.modifiers).toEqual({ hello: true })
-    }
-
-    const vm = new Vue({
-      template: '<div class="hi"><div v-if="ok" v-test:arg.hello="a">{{ msg }}</div></div>',
-      data: {
-        msg: 'hi',
-        a: 'foo',
-        ok: true
-      },
-      directives: {
-        test: {
-          bind (el, binding, vnode) {
-            bindSpy()
-            assertContext(el, binding, vnode)
-            expect(binding.value).toBe('foo')
-            expect(binding.expression).toBe('a')
-            expect(binding.oldValue).toBeUndefined()
-            expect(el.parentNode).toBeNull()
-          },
-          inserted (el, binding, vnode) {
-            insertedSpy()
-            assertContext(el, binding, vnode)
-            expect(binding.value).toBe('foo')
-            expect(binding.expression).toBe('a')
-            expect(binding.oldValue).toBeUndefined()
-            expect(el.parentNode.className).toBe('hi')
-          },
-          update (el, binding, vnode, oldVnode) {
-            updateSpy()
-            assertContext(el, binding, vnode)
-            expect(el).toBe(vm.$el.children[0])
-            expect(oldVnode).not.toBe(vnode)
-            expect(binding.expression).toBe('a')
-            if (binding.value !== binding.oldValue) {
-              expect(binding.value).toBe('bar')
-              expect(binding.oldValue).toBe('foo')
-            }
-          },
-          componentUpdated (el, binding, vnode) {
-            componentUpdatedSpy()
-            assertContext(el, binding, vnode)
-          },
-          unbind (el, binding, vnode) {
-            unbindSpy()
-            assertContext(el, binding, vnode)
-          }
-        }
-      }
-    })
-
-    vm.$mount()
-    expect(bindSpy).toHaveBeenCalled()
-    expect(insertedSpy).toHaveBeenCalled()
-    expect(updateSpy).not.toHaveBeenCalled()
-    expect(componentUpdatedSpy).not.toHaveBeenCalled()
-    expect(unbindSpy).not.toHaveBeenCalled()
-    vm.a = 'bar'
-    waitForUpdate(() => {
-      expect(updateSpy).toHaveBeenCalled()
-      expect(componentUpdatedSpy).toHaveBeenCalled()
-      expect(unbindSpy).not.toHaveBeenCalled()
-      vm.msg = 'bye'
-    }).then(() => {
-      expect(componentUpdatedSpy.calls.count()).toBe(2)
-      vm.ok = false
-    }).then(() => {
-      expect(unbindSpy).toHaveBeenCalled()
-    }).then(done)
-  })
-
-  it('function shorthand', done => {
-    const spy = jasmine.createSpy('directive')
-    const vm = new Vue({
-      template: '<div v-test:arg.hello="a"></div>',
-      data: { a: 'foo' },
-      directives: {
-        test (el, binding, vnode) {
-          expect(vnode.context).toBe(vm)
-          expect(binding.arg).toBe('arg')
-          expect(binding.modifiers).toEqual({ hello: true })
-          spy(binding.value, binding.oldValue)
-        }
-      }
-    })
-    vm.$mount()
-    expect(spy).toHaveBeenCalledWith('foo', undefined)
-    vm.a = 'bar'
-    waitForUpdate(() => {
-      expect(spy).toHaveBeenCalledWith('bar', 'foo')
-    }).then(done)
-  })
-
-  it('function shorthand (global)', done => {
-    const spy = jasmine.createSpy('directive')
-    Vue.directive('test', function (el, binding, vnode) {
-      expect(vnode.context).toBe(vm)
-      expect(binding.arg).toBe('arg')
-      expect(binding.modifiers).toEqual({ hello: true })
-      spy(binding.value, binding.oldValue)
-    })
-    const vm = new Vue({
-      template: '<div v-test:arg.hello="a"></div>',
-      data: { a: 'foo' }
-    })
-    vm.$mount()
-    expect(spy).toHaveBeenCalledWith('foo', undefined)
-    vm.a = 'bar'
-    waitForUpdate(() => {
-      expect(spy).toHaveBeenCalledWith('bar', 'foo')
-      delete Vue.options.directives.test
-    }).then(done)
-  })
-
-  it('should teardown directives on old vnodes when new vnodes have none', done => {
-    const vm = new Vue({
-      data: {
-        ok: true
-      },
-      template: `
-        <div>
-          <div v-if="ok" v-test>a</div>
-          <div v-else class="b">b</div>
-        </div>
-      `,
-      directives: {
-        test: {
-          bind: el => { el.id = 'a' },
-          unbind: el => { el.id = '' }
-        }
-      }
-    }).$mount()
-    expect(vm.$el.children[0].id).toBe('a')
-    vm.ok = false
-    waitForUpdate(() => {
-      expect(vm.$el.children[0].id).toBe('')
-      expect(vm.$el.children[0].className).toBe('b')
-    }).then(done)
-  })
-
-  it('should properly handle same node with different directive sets', done => {
-    const spies = {}
-    const createSpy = name => (spies[name] = jasmine.createSpy(name))
-    const vm = new Vue({
-      data: {
-        ok: true,
-        val: 123
-      },
-      template: `
-        <div>
-          <div v-if="ok" v-test="val" v-test.hi="val"></div>
-          <div v-if="!ok" v-test.hi="val" v-test2="val"></div>
-        </div>
-      `,
-      directives: {
-        test: {
-          bind: createSpy('bind1'),
-          inserted: createSpy('inserted1'),
-          update: createSpy('update1'),
-          componentUpdated: createSpy('componentUpdated1'),
-          unbind: createSpy('unbind1')
-        },
-        test2: {
-          bind: createSpy('bind2'),
-          inserted: createSpy('inserted2'),
-          update: createSpy('update2'),
-          componentUpdated: createSpy('componentUpdated2'),
-          unbind: createSpy('unbind2')
-        }
-      }
-    }).$mount()
-
-    expect(spies.bind1.calls.count()).toBe(2)
-    expect(spies.inserted1.calls.count()).toBe(2)
-    expect(spies.bind2.calls.count()).toBe(0)
-    expect(spies.inserted2.calls.count()).toBe(0)
-
-    vm.ok = false
-    waitForUpdate(() => {
-      // v-test with modifier should be updated
-      expect(spies.update1.calls.count()).toBe(1)
-      expect(spies.componentUpdated1.calls.count()).toBe(1)
-
-      // v-test without modifier should be unbound
-      expect(spies.unbind1.calls.count()).toBe(1)
-
-      // v-test2 should be bound
-      expect(spies.bind2.calls.count()).toBe(1)
-      expect(spies.inserted2.calls.count()).toBe(1)
-
-      vm.ok = true
-    }).then(() => {
-      // v-test without modifier should be bound again
-      expect(spies.bind1.calls.count()).toBe(3)
-      expect(spies.inserted1.calls.count()).toBe(3)
-
-      // v-test2 should be unbound
-      expect(spies.unbind2.calls.count()).toBe(1)
-
-      // v-test with modifier should be updated again
-      expect(spies.update1.calls.count()).toBe(2)
-      expect(spies.componentUpdated1.calls.count()).toBe(2)
-
-      vm.val = 234
-    }).then(() => {
-      expect(spies.update1.calls.count()).toBe(4)
-      expect(spies.componentUpdated1.calls.count()).toBe(4)
-    }).then(done)
-  })
-
-  it('warn non-existent', () => {
-    new Vue({
-      template: '<div v-test></div>'
-    }).$mount()
-    expect('Failed to resolve directive: test').toHaveBeenWarned()
-  })
-
-  // #6513
-  it('should invoke unbind & inserted on inner component root element change', done => {
-    const dir = {
-      bind: jasmine.createSpy('bind'),
-      inserted: jasmine.createSpy('inserted'),
-      unbind: jasmine.createSpy('unbind')
-    }
-
-    const Child = {
-      template: `<div v-if="ok"/><span v-else/>`,
-      data: () => ({ ok: true })
-    }
-
-    const vm = new Vue({
-      template: `<child ref="child" v-test />`,
-      directives: { test: dir },
-      components: { Child }
-    }).$mount()
-
-    const oldEl = vm.$el
-    expect(dir.bind.calls.count()).toBe(1)
-    expect(dir.bind.calls.argsFor(0)[0]).toBe(oldEl)
-    expect(dir.inserted.calls.count()).toBe(1)
-    expect(dir.inserted.calls.argsFor(0)[0]).toBe(oldEl)
-    expect(dir.unbind).not.toHaveBeenCalled()
-
-    vm.$refs.child.ok = false
-    waitForUpdate(() => {
-      expect(vm.$el.tagName).toBe('SPAN')
-      expect(dir.bind.calls.count()).toBe(2)
-      expect(dir.bind.calls.argsFor(1)[0]).toBe(vm.$el)
-      expect(dir.inserted.calls.count()).toBe(2)
-      expect(dir.inserted.calls.argsFor(1)[0]).toBe(vm.$el)
-      expect(dir.unbind.calls.count()).toBe(1)
-      expect(dir.unbind.calls.argsFor(0)[0]).toBe(oldEl)
-    }).then(done)
-  })
-
-  it('dynamic arguments', done => {
-    const vm = new Vue({
-      template: `<div v-my:[key]="1"/>`,
-      data: {
-        key: 'foo'
-      },
-      directives: {
-        my: {
-          bind(el, binding) {
-            expect(binding.arg).toBe('foo')
-          },
-          update(el, binding) {
-            expect(binding.arg).toBe('bar')
-            expect(binding.oldArg).toBe('foo')
-            done()
-          }
-        }
-      }
-    }).$mount()
-    vm.key = 'bar'
-  })
-
-  it('deep object like `deep.a` as dynamic arguments', done => {
-    const vm = new Vue({
-      template: `<div v-my:[deep.a]="1"/>`,
-      data: {
-        deep: {
-          a: 'foo'
-        }
-      },
-      directives: {
-        my: {
-          bind(el, binding) {
-            expect(binding.arg).toBe('foo')
-          },
-          update(el, binding) {
-            expect(binding.arg).toBe('bar')
-            expect(binding.oldArg).toBe('foo')
-            done()
-          }
-        }
-      }
-    }).$mount()
-    vm.deep.a = 'bar'
-  })
-
-  it('deep object like `deep.a.b` as dynamic arguments', done => {
-    const vm = new Vue({
-      template: `<div v-my:[deep.a.b]="1"/>`,
-      data: {
-        deep: {
-          a: {
-            b: 'foo'
-          }
-        }
-      },
-      directives: {
-        my: {
-          bind(el, binding) {
-            expect(binding.arg).toBe('foo')
-          },
-          update(el, binding) {
-            expect(binding.arg).toBe('bar')
-            expect(binding.oldArg).toBe('foo')
-            done()
-          }
-        }
-      }
-    }).$mount()
-    vm.deep.a.b = 'bar'
-  })
-
-  it('deep object as dynamic arguments with modifiers', done => {
-    const vm = new Vue({
-      template: `<div v-my:[deep.a.b].x.y="1"/>`,
-      data: {
-        deep: {
-          a: {
-            b: 'foo'
-          }
-        }
-      },
-      directives: {
-        my: {
-          bind(el, binding) {
-            expect(binding.arg).toBe('foo')
-            expect(binding.modifiers.x).toBe(true)
-            expect(binding.modifiers.y).toBe(true)
-          },
-          update(el, binding) {
-            expect(binding.arg).toBe('bar')
-            expect(binding.oldArg).toBe('foo')
-            done()
-          }
-        }
-      }
-    }).$mount()
-    vm.deep.a.b = 'bar'
-  })
-})
diff --git a/1.Vue/test/unit/features/options/el.spec.js b/1.Vue/test/unit/features/options/el.spec.js
deleted file mode 100644
index 75beda1..0000000
--- a/1.Vue/test/unit/features/options/el.spec.js
+++ /dev/null
@@ -1,90 +0,0 @@
-import Vue from 'vue'
-
-describe('Options el', () => {
-  it('basic usage', () => {
-    const el = document.createElement('div')
-    el.innerHTML = '<span>{{message}}</span>'
-    const vm = new Vue({
-      el,
-      data: { message: 'hello world' }
-    })
-    expect(vm.$el.tagName).toBe('DIV')
-    expect(vm.$el.textContent).toBe(vm.message)
-  })
-
-  it('should be replaced when use together with `template` option', () => {
-    const el = document.createElement('div')
-    el.innerHTML = '<span>{{message}}</span>'
-    const vm = new Vue({
-      el,
-      template: '<p id="app"><span>{{message}}</span></p>',
-      data: { message: 'hello world' }
-    })
-    expect(vm.$el.tagName).toBe('P')
-    expect(vm.$el.textContent).toBe(vm.message)
-  })
-
-  it('should be replaced when use together with `render` option', () => {
-    const el = document.createElement('div')
-    el.innerHTML = '<span>{{message}}</span>'
-    const vm = new Vue({
-      el,
-      render (h) {
-        return h('p', { staticAttrs: { id: 'app' }}, [
-          h('span', {}, [this.message])
-        ])
-      },
-      data: { message: 'hello world' }
-    })
-    expect(vm.$el.tagName).toBe('P')
-    expect(vm.$el.textContent).toBe(vm.message)
-  })
-
-  it('svg element', () => {
-    const parent = document.createElement('div')
-    parent.innerHTML =
-      '<svg>' +
-        '<text :x="x" :y="y" :fill="color">{{ text }}</text>' +
-        '<g><clipPath><foo></foo></clipPath></g>' +
-      '</svg>'
-    const vm = new Vue({
-      el: parent.childNodes[0],
-      data: {
-        x: 64,
-        y: 128,
-        color: 'red',
-        text: 'svg text'
-      }
-    })
-    expect(vm.$el.tagName).toBe('svg')
-    expect(vm.$el.childNodes[0].getAttribute('x')).toBe(vm.x.toString())
-    expect(vm.$el.childNodes[0].getAttribute('y')).toBe(vm.y.toString())
-    expect(vm.$el.childNodes[0].getAttribute('fill')).toBe(vm.color)
-    expect(vm.$el.childNodes[0].textContent).toBe(vm.text)
-    // nested, non-explicitly listed SVG elements
-    expect(vm.$el.childNodes[1].childNodes[0].namespaceURI).toContain('svg')
-    expect(vm.$el.childNodes[1].childNodes[0].childNodes[0].namespaceURI).toContain('svg')
-  })
-
-  // https://w3c.github.io/DOM-Parsing/#dfn-serializing-an-attribute-value
-  it('properly decode attribute values when parsing templates from DOM', () => {
-    const el = document.createElement('div')
-    el.innerHTML = '<a href="/a?foo=bar&baz=qux" name="<abc>" single=\'"hi"\'></a>'
-    const vm = new Vue({ el })
-    expect(vm.$el.children[0].getAttribute('href')).toBe('/a?foo=bar&baz=qux')
-    expect(vm.$el.children[0].getAttribute('name')).toBe('<abc>')
-    expect(vm.$el.children[0].getAttribute('single')).toBe('"hi"')
-  })
-
-  it('decode attribute value newlines when parsing templates from DOM in IE', () => {
-    const el = document.createElement('div')
-    el.innerHTML = `<a :style="{\ncolor:'red'\n}"></a>`
-    const vm = new Vue({ el })
-    expect(vm.$el.children[0].style.color).toBe('red')
-  })
-
-  it('warn cannot find element', () => {
-    new Vue({ el: '#non-existent' })
-    expect('Cannot find element: #non-existent').toHaveBeenWarned()
-  })
-})
diff --git a/1.Vue/test/unit/features/options/errorCaptured.spec.js b/1.Vue/test/unit/features/options/errorCaptured.spec.js
deleted file mode 100644
index 3da13b9..0000000
--- a/1.Vue/test/unit/features/options/errorCaptured.spec.js
+++ /dev/null
@@ -1,250 +0,0 @@
-import Vue from 'vue'
-
-describe('Options errorCaptured', () => {
-  let globalSpy
-
-  beforeEach(() => {
-    globalSpy = Vue.config.errorHandler = jasmine.createSpy()
-  })
-
-  afterEach(() => {
-    Vue.config.errorHandler = null
-  })
-
-  it('should capture error from child component', () => {
-    const spy = jasmine.createSpy()
-
-    let child
-    let err
-    const Child = {
-      created () {
-        child = this
-        err = new Error('child')
-        throw err
-      },
-      render () {}
-    }
-
-    new Vue({
-      errorCaptured: spy,
-      render: h => h(Child)
-    }).$mount()
-
-    expect(spy).toHaveBeenCalledWith(err, child, 'created hook')
-    // should propagate by default
-    expect(globalSpy).toHaveBeenCalledWith(err, child, 'created hook')
-  })
-
-  it('should be able to render the error in itself', done => {
-    let child
-    const Child = {
-      created () {
-        child = this
-        throw new Error('error from child')
-      },
-      render () {}
-    }
-
-    const vm = new Vue({
-      data: {
-        error: null
-      },
-      errorCaptured (e, vm, info) {
-        expect(vm).toBe(child)
-        this.error = e.toString() + ' in ' + info
-      },
-      render (h) {
-        if (this.error) {
-          return h('pre', this.error)
-        }
-        return h(Child)
-      }
-    }).$mount()
-
-    waitForUpdate(() => {
-      expect(vm.$el.textContent).toContain('error from child')
-      expect(vm.$el.textContent).toContain('in created hook')
-    }).then(done)
-  })
-
-  it('should not propagate to global handler when returning true', () => {
-    const spy = jasmine.createSpy()
-
-    let child
-    let err
-    const Child = {
-      created () {
-        child = this
-        err = new Error('child')
-        throw err
-      },
-      render () {}
-    }
-
-    new Vue({
-      errorCaptured (err, vm, info) {
-        spy(err, vm, info)
-        return false
-      },
-      render: h => h(Child, {})
-    }).$mount()
-
-    expect(spy).toHaveBeenCalledWith(err, child, 'created hook')
-    // should not propagate
-    expect(globalSpy).not.toHaveBeenCalled()
-  })
-
-  it('should propagate to global handler if itself throws error', () => {
-    let child
-    let err
-    const Child = {
-      created () {
-        child = this
-        err = new Error('child')
-        throw err
-      },
-      render () {}
-    }
-
-    let err2
-    const vm = new Vue({
-      errorCaptured () {
-        err2 = new Error('foo')
-        throw err2
-      },
-      render: h => h(Child, {})
-    }).$mount()
-
-    expect(globalSpy).toHaveBeenCalledWith(err, child, 'created hook')
-    expect(globalSpy).toHaveBeenCalledWith(err2, vm, 'errorCaptured hook')
-  })
-
-  it('should work across multiple parents, mixins and extends', () => {
-    const calls = []
-
-    const Child = {
-      created () {
-        throw new Error('child')
-      },
-      render () {}
-    }
-
-    const ErrorBoundaryBase = {
-      errorCaptured () {
-        calls.push(1)
-      }
-    }
-
-    const mixin = {
-      errorCaptured () {
-        calls.push(2)
-      }
-    }
-
-    const ErrorBoundaryExtended = {
-      extends: ErrorBoundaryBase,
-      mixins: [mixin],
-      errorCaptured () {
-        calls.push(3)
-      },
-      render: h => h(Child)
-    }
-
-    Vue.config.errorHandler = () => {
-      calls.push(5)
-    }
-
-    new Vue({
-      errorCaptured () {
-        calls.push(4)
-      },
-      render: h => h(ErrorBoundaryExtended)
-    }).$mount()
-
-    expect(calls).toEqual([1, 2, 3, 4, 5])
-  })
-
-  it('should work across multiple parents, mixins and extends with return false', () => {
-    const calls = []
-
-    const Child = {
-      created () {
-        throw new Error('child')
-      },
-      render () {}
-    }
-
-    const ErrorBoundaryBase = {
-      errorCaptured () {
-        calls.push(1)
-      }
-    }
-
-    const mixin = {
-      errorCaptured () {
-        calls.push(2)
-      }
-    }
-
-    const ErrorBoundaryExtended = {
-      extends: ErrorBoundaryBase,
-      mixins: [mixin],
-      errorCaptured () {
-        calls.push(3)
-        return false
-      },
-      render: h => h(Child)
-    }
-
-    Vue.config.errorHandler = () => {
-      calls.push(5)
-    }
-
-    new Vue({
-      errorCaptured () {
-        calls.push(4)
-      },
-      render: h => h(ErrorBoundaryExtended)
-    }).$mount()
-
-    expect(calls).toEqual([1, 2, 3])
-  })
-
-  // ref: https://github.com/vuejs/vuex/issues/1505
-  it('should not add watchers to render deps if they are referred from errorCaptured callback', done => {
-    const store = new Vue({
-      data: {
-        errors: []
-      }
-    })
-
-    const Child = {
-      computed: {
-        test() {
-          throw new Error('render error')
-        }
-      },
-
-      render(h) {
-        return h('div', {
-          attrs: {
-            'data-test': this.test
-          }
-        })
-      }
-    }
-
-    new Vue({
-      errorCaptured(error) {
-        store.errors.push(error)
-      },
-      render: h => h(Child)
-    }).$mount()
-
-    // Ensure not to trigger infinite loop
-    waitForUpdate(() => {
-      expect(store.errors.length).toBe(1)
-      expect(store.errors[0]).toEqual(new Error('render error'))
-    }).then(done)
-  })
-})
diff --git a/1.Vue/test/unit/features/options/extends.spec.js b/1.Vue/test/unit/features/options/extends.spec.js
deleted file mode 100644
index 1734640..0000000
--- a/1.Vue/test/unit/features/options/extends.spec.js
+++ /dev/null
@@ -1,75 +0,0 @@
-import Vue from 'vue'
-import { nativeWatch } from 'core/util/env'
-
-describe('Options extends', () => {
-  it('should work on objects', () => {
-    const A = {
-      data () {
-        return { a: 1 }
-      }
-    }
-    const B = {
-      extends: A,
-      data () {
-        return { b: 2 }
-      }
-    }
-    const vm = new Vue({
-      extends: B,
-      data: {
-        c: 3
-      }
-    })
-    expect(vm.a).toBe(1)
-    expect(vm.b).toBe(2)
-    expect(vm.c).toBe(3)
-  })
-
-  it('should work on extended constructors', () => {
-    const A = Vue.extend({
-      data () {
-        return { a: 1 }
-      }
-    })
-    const B = Vue.extend({
-      extends: A,
-      data () {
-        return { b: 2 }
-      }
-    })
-    const vm = new Vue({
-      extends: B,
-      data: {
-        c: 3
-      }
-    })
-    expect(vm.a).toBe(1)
-    expect(vm.b).toBe(2)
-    expect(vm.c).toBe(3)
-  })
-
-  if (nativeWatch) {
-    it('should work with global mixins + Object.prototype.watch', done => {
-      Vue.mixin({})
-
-      const spy = jasmine.createSpy('watch')
-      const A = Vue.extend({
-        data: function () {
-          return { a: 1 }
-        },
-        watch: {
-          a: spy
-        },
-        created: function () {
-          this.a = 2
-        }
-      })
-      new Vue({
-        extends: A
-      })
-      waitForUpdate(() => {
-        expect(spy).toHaveBeenCalledWith(2, 1)
-      }).then(done)
-    })
-  }
-})
diff --git a/1.Vue/test/unit/features/options/functional.spec.js b/1.Vue/test/unit/features/options/functional.spec.js
deleted file mode 100644
index ea85eea..0000000
--- a/1.Vue/test/unit/features/options/functional.spec.js
+++ /dev/null
@@ -1,363 +0,0 @@
-import Vue from 'vue'
-import { createEmptyVNode } from 'core/vdom/vnode'
-
-describe('Options functional', () => {
-  it('should work', done => {
-    const vm = new Vue({
-      data: { test: 'foo' },
-      template: '<div><wrap :msg="test">bar</wrap></div>',
-      components: {
-        wrap: {
-          functional: true,
-          props: ['msg'],
-          render (h, { props, children }) {
-            return h('div', null, [props.msg, ' '].concat(children))
-          }
-        }
-      }
-    }).$mount()
-    expect(vm.$el.innerHTML).toBe('<div>foo bar</div>')
-    vm.test = 'qux'
-    waitForUpdate(() => {
-      expect(vm.$el.innerHTML).toBe('<div>qux bar</div>')
-    }).then(done)
-  })
-
-  it('should expose all props when not declared', done => {
-    const fn = {
-      functional: true,
-      render (h, { props }) {
-        return h('div', `${props.msg} ${props.kebabMsg}`)
-      }
-    }
-
-    const vm = new Vue({
-      data: { test: 'foo' },
-      render (h) {
-        return h('div', [
-          h(fn, {
-            props: { msg: this.test },
-            attrs: { 'kebab-msg': 'bar' }
-          })
-        ])
-      }
-    }).$mount()
-
-    expect(vm.$el.innerHTML).toBe('<div>foo bar</div>')
-    vm.test = 'qux'
-    waitForUpdate(() => {
-      expect(vm.$el.innerHTML).toBe('<div>qux bar</div>')
-    }).then(done)
-  })
-
-  it('should expose data.on as listeners', () => {
-    const foo = jasmine.createSpy('foo')
-    const bar = jasmine.createSpy('bar')
-    const vm = new Vue({
-      template: '<div><wrap @click="foo" @test="bar"/></div>',
-      methods: { foo, bar },
-      components: {
-        wrap: {
-          functional: true,
-          render (h, { listeners }) {
-            return h('div', {
-              on: {
-                click: [listeners.click, () => listeners.test('bar')]
-              }
-            })
-          }
-        }
-      }
-    }).$mount()
-
-    document.body.appendChild(vm.$el)
-    triggerEvent(vm.$el.children[0], 'click')
-    expect(foo).toHaveBeenCalled()
-    expect(foo.calls.argsFor(0)[0].type).toBe('click') // should have click event
-    triggerEvent(vm.$el.children[0], 'mousedown')
-    expect(bar).toHaveBeenCalledWith('bar')
-    document.body.removeChild(vm.$el)
-  })
-
-  it('should expose scopedSlots on render context', () => {
-    const vm = new Vue({
-      template: '<div><wrap>foo<p slot="p" slot-scope="a">{{ a }}</p></wrap></div>',
-      components: {
-        wrap: {
-          functional: true,
-          render (h, { scopedSlots }) {
-            return [
-              // scoped
-              scopedSlots.p('a'),
-              // normal slot content should be exposed as well
-              scopedSlots.default()
-            ]
-          }
-        }
-      }
-    }).$mount()
-
-    expect(vm.$el.textContent).toBe('afoo')
-  })
-
-  it('should support returning more than one root node', () => {
-    const vm = new Vue({
-      template: `<div><test></test></div>`,
-      components: {
-        test: {
-          functional: true,
-          render (h) {
-            return [h('span', 'foo'), h('span', 'bar')]
-          }
-        }
-      }
-    }).$mount()
-    expect(vm.$el.innerHTML).toBe('<span>foo</span><span>bar</span>')
-  })
-
-  it('should support slots', () => {
-    const vm = new Vue({
-      data: { test: 'foo' },
-      template: '<div><wrap><div slot="a">foo</div><div slot="b">bar</div></wrap></div>',
-      components: {
-        wrap: {
-          functional: true,
-          props: ['msg'],
-          render (h, { slots }) {
-            slots = slots()
-            return h('div', null, [slots.b, slots.a])
-          }
-        }
-      }
-    }).$mount()
-    expect(vm.$el.innerHTML).toBe('<div><div>bar</div><div>foo</div></div>')
-  })
-
-  it('should let vnode raw data pass through', done => {
-    const onValid = jasmine.createSpy('valid')
-    const vm = new Vue({
-      data: { msg: 'hello' },
-      template: `<div>
-        <validate field="field1" @valid="onValid">
-          <input type="text" v-model="msg">
-        </validate>
-      </div>`,
-      components: {
-        validate: {
-          functional: true,
-          props: ['field'],
-          render (h, { props, children, data: { on }}) {
-            props.child = children[0]
-            return h('validate-control', { props, on })
-          }
-        },
-        'validate-control': {
-          props: ['field', 'child'],
-          render () {
-            return this.child
-          },
-          mounted () {
-            this.$el.addEventListener('input', this.onInput)
-          },
-          destroyed () {
-            this.$el.removeEventListener('input', this.onInput)
-          },
-          methods: {
-            onInput (e) {
-              const value = e.target.value
-              if (this.validate(value)) {
-                this.$emit('valid', this)
-              }
-            },
-            // something validation logic here
-            validate (val) {
-              return val.length > 0
-            }
-          }
-        }
-      },
-      methods: { onValid }
-    }).$mount()
-    document.body.appendChild(vm.$el)
-    const input = vm.$el.querySelector('input')
-    expect(onValid).not.toHaveBeenCalled()
-    waitForUpdate(() => {
-      input.value = 'foo'
-      triggerEvent(input, 'input')
-    }).then(() => {
-      expect(onValid).toHaveBeenCalled()
-    }).then(() => {
-      document.body.removeChild(vm.$el)
-      vm.$destroy()
-    }).then(done)
-  })
-
-  it('create empty vnode when render return null', () => {
-    const child = {
-      functional: true,
-      render () {
-        return null
-      }
-    }
-    const vm = new Vue({
-      components: {
-        child
-      }
-    })
-    const h = vm.$createElement
-    const vnode = h('child')
-    expect(vnode).toEqual(createEmptyVNode())
-  })
-
-  // #7282
-  it('should normalize top-level arrays', () => {
-    const Foo = {
-      functional: true,
-      render (h) {
-        return [h('span', 'hi'), null]
-      }
-    }
-    const vm = new Vue({
-      template: `<div><foo/></div>`,
-      components: { Foo }
-    }).$mount()
-    expect(vm.$el.innerHTML).toBe('<span>hi</span>')
-  })
-
-  it('should work when used as named slot and returning array', () => {
-    const Foo = {
-      template: `<div><slot name="test"/></div>`
-    }
-
-    const Bar = {
-      functional: true,
-      render: h => ([
-        h('div', 'one'),
-        h('div', 'two'),
-        h(Baz)
-      ])
-    }
-
-    const Baz = {
-      functional: true,
-      render: h => h('div', 'three')
-    }
-
-    const vm = new Vue({
-      template: `<foo><bar slot="test"/></foo>`,
-      components: { Foo, Bar }
-    }).$mount()
-
-    expect(vm.$el.innerHTML).toBe('<div>one</div><div>two</div><div>three</div>')
-  })
-
-  it('should apply namespace when returning arrays', () => {
-    const Child = {
-      functional: true,
-      render: h => ([h('foo'), h('bar')])
-    }
-    const vm = new Vue({
-      template: `<svg><child/></svg>`,
-      components: { Child }
-    }).$mount()
-
-    expect(vm.$el.childNodes[0].namespaceURI).toContain('svg')
-    expect(vm.$el.childNodes[1].namespaceURI).toContain('svg')
-  })
-
-  it('should work with render fns compiled from template', done => {
-    // code generated via vue-template-es2015-compiler
-    const render = function (_h, _vm) {
-      const _c = _vm._c
-      return _c(
-        'div',
-        [
-          _c('h2', { staticClass: 'red' }, [_vm._v(_vm._s(_vm.props.msg))]),
-          _vm._t('default'),
-          _vm._t('slot2'),
-          _vm._t('scoped', null, { msg: _vm.props.msg }),
-          _vm._m(0),
-          _c('div', { staticClass: 'clickable', on: { click: _vm.parent.fn }}, [
-            _vm._v('click me')
-          ])
-        ],
-        2
-      )
-    }
-    const staticRenderFns = [
-      function (_h, _vm) {
-        const _c = _vm._c
-        return _c('div', [_vm._v('Some '), _c('span', [_vm._v('text')])])
-      }
-    ]
-
-    const child = {
-      functional: true,
-      _compiled: true,
-      render,
-      staticRenderFns
-    }
-
-    const parent = new Vue({
-      components: {
-        child
-      },
-      data: {
-        msg: 'hello'
-      },
-      template: `
-      <div>
-        <child :msg="msg">
-          <span>{{ msg }}</span>
-          <div slot="slot2">Second slot</div>
-          <template slot="scoped" slot-scope="scope">{{ scope.msg }}</template>
-        </child>
-      </div>
-      `,
-      methods: {
-        fn () {
-          this.msg = 'bye'
-        }
-      }
-    }).$mount()
-
-    function assertMarkup () {
-      expect(parent.$el.innerHTML).toBe(
-        `<div>` +
-          `<h2 class="red">${parent.msg}</h2>` +
-          `<span>${parent.msg}</span> ` +
-          `<div>Second slot</div>` +
-          parent.msg +
-          // static
-          `<div>Some <span>text</span></div>` +
-          `<div class="clickable">click me</div>` +
-        `</div>`
-      )
-    }
-
-    assertMarkup()
-    triggerEvent(parent.$el.querySelector('.clickable'), 'click')
-    waitForUpdate(assertMarkup).then(done)
-  })
-
-  // #8468
-  it('should normalize nested arrays when use functional components with v-for', () => {
-    const Foo = {
-      functional: true,
-      props: {
-        name: {}
-      },
-      render (h, context) {
-        return [h('span', 'hi'), h('span', context.props.name)]
-      }
-    }
-    const vm = new Vue({
-      template: `<div><foo v-for="name in names" :name="name" /></div>`,
-      data: {
-        names: ['foo', 'bar']
-      },
-      components: { Foo }
-    }).$mount()
-    expect(vm.$el.innerHTML).toBe('<span>hi</span><span>foo</span><span>hi</span><span>bar</span>')
-  })
-})
diff --git a/1.Vue/test/unit/features/options/inheritAttrs.spec.js b/1.Vue/test/unit/features/options/inheritAttrs.spec.js
deleted file mode 100644
index 7ccc7c0..0000000
--- a/1.Vue/test/unit/features/options/inheritAttrs.spec.js
+++ /dev/null
@@ -1,39 +0,0 @@
-import Vue from 'vue'
-
-describe('Options inheritAttrs', () => {
-  it('should work', done => {
-    const vm = new Vue({
-      template: `<foo :id="foo"/>`,
-      data: { foo: 'foo' },
-      components: {
-        foo: {
-          inheritAttrs: false,
-          template: `<div>foo</div>`
-        }
-      }
-    }).$mount()
-    expect(vm.$el.id).toBe('')
-    vm.foo = 'bar'
-    waitForUpdate(() => {
-      expect(vm.$el.id).toBe('')
-    }).then(done)
-  })
-
-  it('with inner v-bind', done => {
-    const vm = new Vue({
-      template: `<foo :id="foo"/>`,
-      data: { foo: 'foo' },
-      components: {
-        foo: {
-          inheritAttrs: false,
-          template: `<div><div v-bind="$attrs"></div></div>`
-        }
-      }
-    }).$mount()
-    expect(vm.$el.children[0].id).toBe('foo')
-    vm.foo = 'bar'
-    waitForUpdate(() => {
-      expect(vm.$el.children[0].id).toBe('bar')
-    }).then(done)
-  })
-})
diff --git a/1.Vue/test/unit/features/options/inject.spec.js b/1.Vue/test/unit/features/options/inject.spec.js
deleted file mode 100644
index 3b47ef5..0000000
--- a/1.Vue/test/unit/features/options/inject.spec.js
+++ /dev/null
@@ -1,676 +0,0 @@
-import Vue from 'vue'
-import { Observer } from 'core/observer/index'
-import { isNative, isObject, hasOwn } from 'core/util/index'
-import testObjectOption from '../../../helpers/test-object-option'
-
-describe('Options provide/inject', () => {
-  testObjectOption('inject')
-
-  let injected
-  const injectedComp = {
-    inject: ['foo', 'bar'],
-    render () {},
-    created () {
-      injected = [this.foo, this.bar]
-    }
-  }
-
-  beforeEach(() => {
-    injected = null
-  })
-
-  it('should work', () => {
-    new Vue({
-      template: `<child/>`,
-      provide: {
-        foo: 1,
-        bar: false
-      },
-      components: {
-        child: {
-          template: `<injected-comp/>`,
-          components: {
-            injectedComp
-          }
-        }
-      }
-    }).$mount()
-
-    expect(injected).toEqual([1, false])
-  })
-
-  it('should use closest parent', () => {
-    new Vue({
-      template: `<child/>`,
-      provide: {
-        foo: 1,
-        bar: null
-      },
-      components: {
-        child: {
-          provide: {
-            foo: 3
-          },
-          template: `<injected-comp/>`,
-          components: {
-            injectedComp
-          }
-        }
-      }
-    }).$mount()
-
-    expect(injected).toEqual([3, null])
-  })
-
-  it('provide function', () => {
-    new Vue({
-      template: `<child/>`,
-      data: {
-        a: 1,
-        b: false
-      },
-      provide () {
-        return {
-          foo: this.a,
-          bar: this.b
-        }
-      },
-      components: {
-        child: {
-          template: `<injected-comp/>`,
-          components: {
-            injectedComp
-          }
-        }
-      }
-    }).$mount()
-
-    expect(injected).toEqual([1, false])
-  })
-
-  it('inject with alias', () => {
-    const injectAlias = {
-      inject: {
-        baz: 'foo',
-        qux: 'bar'
-      },
-      render () {},
-      created () {
-        injected = [this.baz, this.qux]
-      }
-    }
-
-    new Vue({
-      template: `<child/>`,
-      provide: {
-        foo: false,
-        bar: 2
-      },
-      components: {
-        child: {
-          template: `<inject-alias/>`,
-          components: {
-            injectAlias
-          }
-        }
-      }
-    }).$mount()
-
-    expect(injected).toEqual([false, 2])
-  })
-
-  it('inject before resolving data/props', () => {
-    const vm = new Vue({
-      provide: {
-        foo: 1
-      }
-    })
-
-    const child = new Vue({
-      parent: vm,
-      inject: ['foo'],
-      data () {
-        return {
-          bar: this.foo + 1
-        }
-      },
-      props: {
-        baz: {
-          default () {
-            return this.foo + 2
-          }
-        }
-      }
-    })
-
-    expect(child.foo).toBe(1)
-    expect(child.bar).toBe(2)
-    expect(child.baz).toBe(3)
-  })
-
-  // GitHub issue #5194
-  it('should work with functional', () => {
-    new Vue({
-      template: `<child/>`,
-      provide: {
-        foo: 1,
-        bar: false
-      },
-      components: {
-        child: {
-          functional: true,
-          inject: ['foo', 'bar'],
-          render (h, context) {
-            const { injections } = context
-            injected = [injections.foo, injections.bar]
-          }
-        }
-      }
-    }).$mount()
-
-    expect(injected).toEqual([1, false])
-  })
-
-  if (typeof Reflect !== 'undefined' && isNative(Reflect.ownKeys)) {
-    it('with Symbol keys', () => {
-      const s = Symbol()
-      const vm = new Vue({
-        template: `<child/>`,
-        provide: {
-          [s]: 123
-        },
-        components: {
-          child: {
-            inject: { s },
-            template: `<div>{{ s }}</div>`
-          }
-        }
-      }).$mount()
-      expect(vm.$el.textContent).toBe('123')
-    })
-
-    it('should merge symbol provide from mixins (functions)', () => {
-      const keyA = Symbol('foo')
-      const keyB = Symbol('bar')
-
-      const mixinA = { provide: () => ({ [keyA]: 'foo' }) }
-      const mixinB = { provide: () => ({ [keyB]: 'bar' }) }
-      const child = {
-        inject: {
-          foo: keyA,
-          bar: keyB
-        },
-        template: `<span/>`,
-        created () {
-          injected = [this.foo, this.bar]
-        }
-      }
-      new Vue({
-        mixins: [mixinA, mixinB],
-        render (h) {
-          return h(child)
-        }
-      }).$mount()
-
-      expect(injected).toEqual(['foo', 'bar'])
-    })
-  }
-
-  // GitHub issue #5223
-  it('should work with reactive array', done => {
-    const vm = new Vue({
-      template: `<div><child></child></div>`,
-      data () {
-        return {
-          foo: []
-        }
-      },
-      provide () {
-        return {
-          foo: this.foo
-        }
-      },
-      components: {
-        child: {
-          inject: ['foo'],
-          template: `<span>{{foo.length}}</span>`
-        }
-      }
-    }).$mount()
-
-    expect(vm.$el.innerHTML).toEqual(`<span>0</span>`)
-    vm.foo.push(vm.foo.length)
-    vm.$nextTick(() => {
-      expect(vm.$el.innerHTML).toEqual(`<span>1</span>`)
-      vm.foo.pop()
-      vm.$nextTick(() => {
-        expect(vm.$el.innerHTML).toEqual(`<span>0</span>`)
-        done()
-      })
-    })
-  })
-
-  it('should extend properly', () => {
-    const parent = Vue.extend({
-      template: `<span/>`,
-      inject: ['foo']
-    })
-
-    const child = parent.extend({
-      template: `<span/>`,
-      inject: ['bar'],
-      created () {
-        injected = [this.foo, this.bar]
-      }
-    })
-
-    new Vue({
-      template: `<div><parent/><child/></div>`,
-      provide: {
-        foo: 1,
-        bar: false
-      },
-      components: {
-        parent,
-        child
-      }
-    }).$mount()
-
-    expect(injected).toEqual([1, false])
-  })
-
-  it('should merge from mixins properly (objects)', () => {
-    const mixinA = { inject: { foo: 'foo' }}
-    const mixinB = { inject: { bar: 'bar' }}
-    const child = {
-      mixins: [mixinA, mixinB],
-      template: `<span/>`,
-      created () {
-        injected = [this.foo, this.bar]
-      }
-    }
-    new Vue({
-      provide: { foo: 'foo', bar: 'bar', baz: 'baz' },
-      render (h) {
-        return h(child)
-      }
-    }).$mount()
-
-    expect(injected).toEqual(['foo', 'bar'])
-  })
-
-  it('should merge from mixins properly (arrays)', () => {
-    const mixinA = { inject: ['foo'] }
-    const mixinB = { inject: ['bar'] }
-    const child = {
-      mixins: [mixinA, mixinB],
-      inject: ['baz'],
-      template: `<span/>`,
-      created () {
-        injected = [this.foo, this.bar, this.baz]
-      }
-    }
-    new Vue({
-      provide: { foo: 'foo', bar: 'bar', baz: 'baz' },
-      render (h) {
-        return h(child)
-      }
-    }).$mount()
-
-    expect(injected).toEqual(['foo', 'bar', 'baz'])
-  })
-
-  it('should merge from mixins properly (mix of objects and arrays)', () => {
-    const mixinA = { inject: { foo: 'foo' }}
-    const mixinB = { inject: ['bar'] }
-    const child = {
-      mixins: [mixinA, mixinB],
-      inject: { qux: 'baz' },
-      template: `<span/>`,
-      created () {
-        injected = [this.foo, this.bar, this.qux]
-      }
-    }
-    new Vue({
-      provide: { foo: 'foo', bar: 'bar', baz: 'baz' },
-      render (h) {
-        return h(child)
-      }
-    }).$mount()
-
-    expect(injected).toEqual(['foo', 'bar', 'baz'])
-  })
-
-  it('should warn when injections has been modified', () => {
-    const key = 'foo'
-    const vm = new Vue({
-      provide: {
-        foo: 1
-      }
-    })
-
-    const child = new Vue({
-      parent: vm,
-      inject: ['foo']
-    })
-
-    expect(child.foo).toBe(1)
-    child.foo = 2
-    expect(
-      `Avoid mutating an injected value directly since the changes will be ` +
-      `overwritten whenever the provided component re-renders. ` +
-      `injection being mutated: "${key}"`).toHaveBeenWarned()
-  })
-
-  it('should warn when injections cannot be found', () => {
-    const vm = new Vue({})
-    new Vue({
-      parent: vm,
-      inject: ['foo', 'bar'],
-      created () {}
-    })
-    expect(`Injection "foo" not found`).toHaveBeenWarned()
-    expect(`Injection "bar" not found`).toHaveBeenWarned()
-  })
-
-  it('should not warn when injections can be found', () => {
-    const vm = new Vue({
-      provide: {
-        foo: 1,
-        bar: false,
-        baz: undefined
-      }
-    })
-    new Vue({
-      parent: vm,
-      inject: ['foo', 'bar', 'baz'],
-      created () {}
-    })
-    expect(`Injection "foo" not found`).not.toHaveBeenWarned()
-    expect(`Injection "bar" not found`).not.toHaveBeenWarned()
-    expect(`Injection "baz" not found`).not.toHaveBeenWarned()
-  })
-
-  it('should not warn when injection key which is not provided is not enumerable', () => {
-    const parent = new Vue({ provide: { foo: 1 }})
-    const inject = { foo: 'foo' }
-    Object.defineProperty(inject, '__ob__', { enumerable: false, value: '__ob__' })
-    new Vue({ parent, inject })
-    expect(`Injection "__ob__" not found`).not.toHaveBeenWarned()
-  })
-
-  // Github issue #6097
-  it('should not warn when injections cannot be found but have default value', () => {
-    const vm = new Vue({})
-    new Vue({
-      parent: vm,
-      inject: {
-        foo: { default: 1 },
-        bar: { default: false },
-        baz: { default: undefined }
-      },
-      created () {
-        injected = [this.foo, this.bar, this.baz]
-      }
-    })
-    expect(injected).toEqual([1, false, undefined])
-  })
-
-  it('should support name alias and default together', () => {
-    const vm = new Vue({
-      provide: {
-        FOO: 2
-      }
-    })
-    new Vue({
-      parent: vm,
-      inject: {
-        foo: { from: 'FOO', default: 1 },
-        bar: { default: false },
-        baz: { default: undefined }
-      },
-      created () {
-        injected = [this.foo, this.bar, this.baz]
-      }
-    })
-    expect(injected).toEqual([2, false, undefined])
-  })
-
-  it('should use provided value even if inject has default', () => {
-    const vm = new Vue({
-      provide: {
-        foo: 1,
-        bar: false,
-        baz: undefined
-      }
-    })
-    new Vue({
-      parent: vm,
-      inject: {
-        foo: { default: 2 },
-        bar: { default: 2 },
-        baz: { default: 2 }
-      },
-      created () {
-        injected = [this.foo, this.bar, this.baz]
-      }
-    })
-    expect(injected).toEqual([1, false, undefined])
-  })
-
-  // Github issue #6008
-  it('should merge provide from mixins (objects)', () => {
-    const mixinA = { provide: { foo: 'foo' }}
-    const mixinB = { provide: { bar: 'bar' }}
-    const child = {
-      inject: ['foo', 'bar'],
-      template: `<span/>`,
-      created () {
-        injected = [this.foo, this.bar]
-      }
-    }
-    new Vue({
-      mixins: [mixinA, mixinB],
-      render (h) {
-        return h(child)
-      }
-    }).$mount()
-
-    expect(injected).toEqual(['foo', 'bar'])
-  })
-
-  it('should merge provide from mixins (functions)', () => {
-    const mixinA = { provide: () => ({ foo: 'foo' }) }
-    const mixinB = { provide: () => ({ bar: 'bar' }) }
-    const child = {
-      inject: ['foo', 'bar'],
-      template: `<span/>`,
-      created () {
-        injected = [this.foo, this.bar]
-      }
-    }
-    new Vue({
-      mixins: [mixinA, mixinB],
-      render (h) {
-        return h(child)
-      }
-    }).$mount()
-
-    expect(injected).toEqual(['foo', 'bar'])
-  })
-
-  it('should merge provide from mixins (mix of objects and functions)', () => {
-    const mixinA = { provide: { foo: 'foo' }}
-    const mixinB = { provide: () => ({ bar: 'bar' }) }
-    const mixinC = { provide: { baz: 'baz' }}
-    const mixinD = { provide: () => ({ bam: 'bam' }) }
-    const child = {
-      inject: ['foo', 'bar', 'baz', 'bam'],
-      template: `<span/>`,
-      created () {
-        injected = [this.foo, this.bar, this.baz, this.bam]
-      }
-    }
-    new Vue({
-      mixins: [mixinA, mixinB, mixinC, mixinD],
-      render (h) {
-        return h(child)
-      }
-    }).$mount()
-
-    expect(injected).toEqual(['foo', 'bar', 'baz', 'bam'])
-  })
-
-  it('should merge provide from mixins and override existing keys', () => {
-    const mixinA = { provide: { foo: 'foo' }}
-    const mixinB = { provide: { foo: 'bar' }}
-    const child = {
-      inject: ['foo'],
-      template: `<span/>`,
-      created () {
-        injected = [this.foo]
-      }
-    }
-    new Vue({
-      mixins: [mixinA, mixinB],
-      render (h) {
-        return h(child)
-      }
-    }).$mount()
-
-    expect(injected).toEqual(['bar'])
-  })
-
-  it('should merge provide when Vue.extend', () => {
-    const mixinA = { provide: () => ({ foo: 'foo' }) }
-    const child = {
-      inject: ['foo', 'bar'],
-      template: `<span/>`,
-      created () {
-        injected = [this.foo, this.bar]
-      }
-    }
-    const Ctor = Vue.extend({
-      mixins: [mixinA],
-      provide: { bar: 'bar' },
-      render (h) {
-        return h(child)
-      }
-    })
-
-    new Ctor().$mount()
-
-    expect(injected).toEqual(['foo', 'bar'])
-  })
-
-  // #5913
-  it('should keep the reactive with provide', () => {
-    function isObserver (obj) {
-      if (isObject(obj)) {
-        return hasOwn(obj, '__ob__') && obj.__ob__ instanceof Observer
-      }
-      return false
-    }
-
-    const vm = new Vue({
-      template: `<div><child ref='child'></child></div>`,
-      data () {
-        return {
-          foo: {},
-          $foo: {},
-          foo1: []
-        }
-      },
-      provide () {
-        return {
-          foo: this.foo,
-          $foo: this.$foo,
-          foo1: this.foo1,
-          bar: {},
-          baz: []
-        }
-      },
-      components: {
-        child: {
-          inject: ['foo', '$foo', 'foo1', 'bar', 'baz'],
-          template: `<span/>`
-        }
-      }
-    }).$mount()
-    const child = vm.$refs.child
-    expect(isObserver(child.foo)).toBe(true)
-    expect(isObserver(child.$foo)).toBe(false)
-    expect(isObserver(child.foo1)).toBe(true)
-    expect(isObserver(child.bar)).toBe(false)
-    expect(isObserver(child.baz)).toBe(false)
-  })
-
-  // #6175
-  it('merge provide properly from mixins', () => {
-    const ProvideFooMixin = {
-      provide: {
-        foo: 'foo injected'
-      }
-    }
-
-    const ProvideBarMixin = {
-      provide: {
-        bar: 'bar injected'
-      }
-    }
-
-    const Child = {
-      inject: ['foo', 'bar'],
-      render (h) {
-        return h('div', [`foo: ${this.foo}, `, `bar: ${this.bar}`])
-      }
-    }
-
-    const Parent = {
-      mixins: [ProvideFooMixin, ProvideBarMixin],
-      render (h) {
-        return h(Child)
-      }
-    }
-
-    const vm = new Vue({
-      render (h) {
-        return h(Parent)
-      }
-    }).$mount()
-
-    expect(vm.$el.textContent).toBe(`foo: foo injected, bar: bar injected`)
-  })
-
-  it('merge provide with object syntax when using Vue.extend', () => {
-    const child = {
-      inject: ['foo'],
-      template: `<span/>`,
-      created () {
-        injected = this.foo
-      }
-    }
-    const Ctor = Vue.extend({
-      provide: { foo: 'foo' },
-      render (h) {
-        return h(child)
-      }
-    })
-
-    new Ctor().$mount()
-
-    expect(injected).toEqual('foo')
-  })
-
-  // #7284
-  it('should not inject prototype properties', () => {
-    const vm = new Vue({
-      provide: {}
-    })
-    new Vue({
-      parent: vm,
-      inject: ['constructor']
-    })
-    expect(`Injection "constructor" not found`).toHaveBeenWarned()
-  })
-})
diff --git a/1.Vue/test/unit/features/options/lifecycle.spec.js b/1.Vue/test/unit/features/options/lifecycle.spec.js
deleted file mode 100644
index 6f48ba0..0000000
--- a/1.Vue/test/unit/features/options/lifecycle.spec.js
+++ /dev/null
@@ -1,338 +0,0 @@
-import Vue from 'vue'
-
-describe('Options lifecycle hooks', () => {
-  let spy
-  beforeEach(() => {
-    spy = jasmine.createSpy('hook')
-  })
-
-  describe('beforeCreate', () => {
-    it('should allow modifying options', () => {
-      const vm = new Vue({
-        data: {
-          a: 1
-        },
-        beforeCreate () {
-          spy()
-          expect(this.a).toBeUndefined()
-          this.$options.computed = {
-            b () {
-              return this.a + 1
-            }
-          }
-        }
-      })
-      expect(spy).toHaveBeenCalled()
-      expect(vm.b).toBe(2)
-    })
-  })
-
-  describe('created', () => {
-    it('should have completed observation', () => {
-      new Vue({
-        data: {
-          a: 1
-        },
-        created () {
-          expect(this.a).toBe(1)
-          spy()
-        }
-      })
-      expect(spy).toHaveBeenCalled()
-    })
-  })
-
-  describe('beforeMount', () => {
-    it('should not have mounted', () => {
-      const vm = new Vue({
-        render () {},
-        beforeMount () {
-          spy()
-          expect(this._isMounted).toBe(false)
-          expect(this.$el).toBeUndefined() // due to empty mount
-          expect(this._vnode).toBeNull()
-          expect(this._watcher).toBeNull()
-        }
-      })
-      expect(spy).not.toHaveBeenCalled()
-      vm.$mount()
-      expect(spy).toHaveBeenCalled()
-    })
-  })
-
-  describe('mounted', () => {
-    it('should have mounted', () => {
-      const vm = new Vue({
-        template: '<div></div>',
-        mounted () {
-          spy()
-          expect(this._isMounted).toBe(true)
-          expect(this.$el.tagName).toBe('DIV')
-          expect(this._vnode.tag).toBe('div')
-        }
-      })
-      expect(spy).not.toHaveBeenCalled()
-      vm.$mount()
-      expect(spy).toHaveBeenCalled()
-    })
-
-    // #3898
-    it('should call for manually mounted instance with parent', () => {
-      const parent = new Vue()
-      expect(spy).not.toHaveBeenCalled()
-      new Vue({
-        parent,
-        template: '<div></div>',
-        mounted () {
-          spy()
-        }
-      }).$mount()
-      expect(spy).toHaveBeenCalled()
-    })
-
-    it('should mount child parent in correct order', () => {
-      const calls = []
-      new Vue({
-        template: '<div><test></test></div>',
-        mounted () {
-          calls.push('parent')
-        },
-        components: {
-          test: {
-            template: '<nested></nested>',
-            mounted () {
-              expect(this.$el.parentNode).toBeTruthy()
-              calls.push('child')
-            },
-            components: {
-              nested: {
-                template: '<div></div>',
-                mounted () {
-                  expect(this.$el.parentNode).toBeTruthy()
-                  calls.push('nested')
-                }
-              }
-            }
-          }
-        }
-      }).$mount()
-      expect(calls).toEqual(['nested', 'child', 'parent'])
-    })
-  })
-
-  describe('beforeUpdate', () => {
-    it('should be called before update', done => {
-      const vm = new Vue({
-        template: '<div>{{ msg }}</div>',
-        data: { msg: 'foo' },
-        beforeUpdate () {
-          spy()
-          expect(this.$el.textContent).toBe('foo')
-        }
-      }).$mount()
-      expect(spy).not.toHaveBeenCalled()
-      vm.msg = 'bar'
-      expect(spy).not.toHaveBeenCalled() // should be async
-      waitForUpdate(() => {
-        expect(spy).toHaveBeenCalled()
-      }).then(done)
-    })
-
-    it('should be called before render and allow mutating state', done => {
-      const vm = new Vue({
-        template: '<div>{{ msg }}</div>',
-        data: { msg: 'foo' },
-        beforeUpdate () {
-          this.msg += '!'
-        }
-      }).$mount()
-      expect(vm.$el.textContent).toBe('foo')
-      vm.msg = 'bar'
-      waitForUpdate(() => {
-        expect(vm.$el.textContent).toBe('bar!')
-      }).then(done)
-    })
-
-    // #8076
-    it('should not be called after destroy', done => {
-      const beforeUpdate = jasmine.createSpy('beforeUpdate')
-      const destroyed = jasmine.createSpy('destroyed')
-
-      Vue.component('todo', {
-        template: '<div>{{todo.done}}</div>',
-        props: ['todo'],
-        destroyed,
-        beforeUpdate
-      })
-
-      const vm = new Vue({
-        template: `
-          <div>
-            <todo v-for="t in pendingTodos" :todo="t" :key="t.id"></todo>
-          </div>
-        `,
-        data () {
-          return {
-            todos: [{ id: 1, done: false }]
-          }
-        },
-        computed: {
-          pendingTodos () {
-            return this.todos.filter(t => !t.done)
-          }
-        }
-      }).$mount()
-
-      vm.todos[0].done = true
-      waitForUpdate(() => {
-        expect(destroyed).toHaveBeenCalled()
-        expect(beforeUpdate).not.toHaveBeenCalled()
-      }).then(done)
-    })
-  })
-
-  describe('updated', () => {
-    it('should be called after update', done => {
-      const vm = new Vue({
-        template: '<div>{{ msg }}</div>',
-        data: { msg: 'foo' },
-        updated () {
-          spy()
-          expect(this.$el.textContent).toBe('bar')
-        }
-      }).$mount()
-      expect(spy).not.toHaveBeenCalled()
-      vm.msg = 'bar'
-      expect(spy).not.toHaveBeenCalled() // should be async
-      waitForUpdate(() => {
-        expect(spy).toHaveBeenCalled()
-      }).then(done)
-    })
-
-    it('should be called after children are updated', done => {
-      const calls = []
-      const vm = new Vue({
-        template: '<div><test ref="child">{{ msg }}</test></div>',
-        data: { msg: 'foo' },
-        components: {
-          test: {
-            template: `<div><slot></slot></div>`,
-            updated () {
-              expect(this.$el.textContent).toBe('bar')
-              calls.push('child')
-            }
-          }
-        },
-        updated () {
-          expect(this.$el.textContent).toBe('bar')
-          calls.push('parent')
-        }
-      }).$mount()
-
-      expect(calls).toEqual([])
-      vm.msg = 'bar'
-      expect(calls).toEqual([])
-      waitForUpdate(() => {
-        expect(calls).toEqual(['child', 'parent'])
-      }).then(done)
-    })
-
-    // #8076
-    it('should not be called after destroy', done => {
-      const updated = jasmine.createSpy('updated')
-      const destroyed = jasmine.createSpy('destroyed')
-
-      Vue.component('todo', {
-        template: '<div>{{todo.done}}</div>',
-        props: ['todo'],
-        destroyed,
-        updated
-      })
-
-      const vm = new Vue({
-        template: `
-          <div>
-            <todo v-for="t in pendingTodos" :todo="t" :key="t.id"></todo>
-          </div>
-        `,
-        data () {
-          return {
-            todos: [{ id: 1, done: false }]
-          }
-        },
-        computed: {
-          pendingTodos () {
-            return this.todos.filter(t => !t.done)
-          }
-        }
-      }).$mount()
-
-      vm.todos[0].done = true
-      waitForUpdate(() => {
-        expect(destroyed).toHaveBeenCalled()
-        expect(updated).not.toHaveBeenCalled()
-      }).then(done)
-    })
-  })
-
-  describe('beforeDestroy', () => {
-    it('should be called before destroy', () => {
-      const vm = new Vue({
-        render () {},
-        beforeDestroy () {
-          spy()
-          expect(this._isBeingDestroyed).toBe(false)
-          expect(this._isDestroyed).toBe(false)
-        }
-      }).$mount()
-      expect(spy).not.toHaveBeenCalled()
-      vm.$destroy()
-      vm.$destroy()
-      expect(spy).toHaveBeenCalled()
-      expect(spy.calls.count()).toBe(1)
-    })
-  })
-
-  describe('destroyed', () => {
-    it('should be called after destroy', () => {
-      const vm = new Vue({
-        render () {},
-        destroyed () {
-          spy()
-          expect(this._isBeingDestroyed).toBe(true)
-          expect(this._isDestroyed).toBe(true)
-        }
-      }).$mount()
-      expect(spy).not.toHaveBeenCalled()
-      vm.$destroy()
-      vm.$destroy()
-      expect(spy).toHaveBeenCalled()
-      expect(spy.calls.count()).toBe(1)
-    })
-  })
-
-  it('should emit hook events', () => {
-    const created = jasmine.createSpy()
-    const mounted = jasmine.createSpy()
-    const destroyed = jasmine.createSpy()
-    const vm = new Vue({
-      render () {},
-      beforeCreate () {
-        this.$on('hook:created', created)
-        this.$on('hook:mounted', mounted)
-        this.$on('hook:destroyed', destroyed)
-      }
-    })
-
-    expect(created).toHaveBeenCalled()
-    expect(mounted).not.toHaveBeenCalled()
-    expect(destroyed).not.toHaveBeenCalled()
-
-    vm.$mount()
-    expect(mounted).toHaveBeenCalled()
-    expect(destroyed).not.toHaveBeenCalled()
-
-    vm.$destroy()
-    expect(destroyed).toHaveBeenCalled()
-  })
-})
diff --git a/1.Vue/test/unit/features/options/methods.spec.js b/1.Vue/test/unit/features/options/methods.spec.js
deleted file mode 100644
index f1e5fc6..0000000
--- a/1.Vue/test/unit/features/options/methods.spec.js
+++ /dev/null
@@ -1,51 +0,0 @@
-import Vue from 'vue'
-import testObjectOption from '../../../helpers/test-object-option'
-
-describe('Options methods', () => {
-  testObjectOption('methods')
-
-  it('should have correct context', () => {
-    const vm = new Vue({
-      data: {
-        a: 1
-      },
-      methods: {
-        plus () {
-          this.a++
-        }
-      }
-    })
-    vm.plus()
-    expect(vm.a).toBe(2)
-  })
-
-  it('should warn methods of not function type', () => {
-    new Vue({
-      methods: {
-        hello: {}
-      }
-    })
-    expect('Method "hello" has type "object" in the component definition').toHaveBeenWarned()
-  })
-
-  it('should warn methods conflicting with data', () => {
-    new Vue({
-      data: {
-        foo: 1
-      },
-      methods: {
-        foo () {}
-      }
-    })
-    expect(`Method "foo" has already been defined as a data property`).toHaveBeenWarned()
-  })
-
-  it('should warn methods conflicting with internal methods', () => {
-    new Vue({
-      methods: {
-        _update () {}
-      }
-    })
-    expect(`Method "_update" conflicts with an existing Vue instance method`).toHaveBeenWarned()
-  })
-})
diff --git a/1.Vue/test/unit/features/options/mixins.spec.js b/1.Vue/test/unit/features/options/mixins.spec.js
deleted file mode 100644
index 373f886..0000000
--- a/1.Vue/test/unit/features/options/mixins.spec.js
+++ /dev/null
@@ -1,144 +0,0 @@
-import Vue from 'vue'
-import { mergeOptions } from 'core/util/index'
-
-describe('Options mixins', () => {
-  it('vm should have options from mixin', () => {
-    const mixin = {
-      directives: {
-        c: {}
-      },
-      methods: {
-        a: function () {}
-      }
-    }
-
-    const vm = new Vue({
-      mixins: [mixin],
-      methods: {
-        b: function () {}
-      }
-    })
-
-    expect(vm.a).toBeDefined()
-    expect(vm.b).toBeDefined()
-    expect(vm.$options.directives.c).toBeDefined()
-  })
-
-  it('should call hooks from mixins first', () => {
-    const a = {}
-    const b = {}
-    const c = {}
-    const f1 = function () {}
-    const f2 = function () {}
-    const f3 = function () {}
-    const mixinA = {
-      a: 1,
-      template: 'foo',
-      directives: {
-        a: a
-      },
-      created: f1
-    }
-    const mixinB = {
-      b: 1,
-      directives: {
-        b: b
-      },
-      created: f2
-    }
-    const result = mergeOptions({}, {
-      directives: {
-        c: c
-      },
-      template: 'bar',
-      mixins: [mixinA, mixinB],
-      created: f3
-    })
-    expect(result.a).toBe(1)
-    expect(result.b).toBe(1)
-    expect(result.directives.a).toBe(a)
-    expect(result.directives.b).toBe(b)
-    expect(result.directives.c).toBe(c)
-    expect(result.created[0]).toBe(f1)
-    expect(result.created[1]).toBe(f2)
-    expect(result.created[2]).toBe(f3)
-    expect(result.template).toBe('bar')
-  })
-
-  it('mixin methods should not override defined method', () => {
-    const f1 = function () {}
-    const f2 = function () {}
-    const f3 = function () {}
-    const mixinA = {
-      methods: {
-        xyz: f1
-      }
-    }
-    const mixinB = {
-      methods: {
-        xyz: f2
-      }
-    }
-    const result = mergeOptions({}, {
-      mixins: [mixinA, mixinB],
-      methods: {
-        xyz: f3
-      }
-    })
-    expect(result.methods.xyz).toBe(f3)
-  })
-
-  it('should accept constructors as mixins', () => {
-    const mixin = Vue.extend({
-      directives: {
-        c: {}
-      },
-      methods: {
-        a: function () {}
-      }
-    })
-
-    const vm = new Vue({
-      mixins: [mixin],
-      methods: {
-        b: function () {}
-      }
-    })
-
-    expect(vm.a).toBeDefined()
-    expect(vm.b).toBeDefined()
-    expect(vm.$options.directives.c).toBeDefined()
-  })
-
-  it('should accept further extended constructors as mixins', () => {
-    const spy1 = jasmine.createSpy('mixinA')
-    const spy2 = jasmine.createSpy('mixinB')
-
-    const mixinA = Vue.extend({
-      created: spy1,
-      directives: {
-        c: {}
-      },
-      methods: {
-        a: function () {}
-      }
-    })
-
-    const mixinB = mixinA.extend({
-      created: spy2
-    })
-
-    const vm = new Vue({
-      mixins: [mixinB],
-      methods: {
-        b: function () {}
-      }
-    })
-
-    expect(spy1).toHaveBeenCalledTimes(1)
-    expect(spy2).toHaveBeenCalledTimes(1)
-    expect(vm.a).toBeDefined()
-    expect(vm.b).toBeDefined()
-    expect(vm.$options.directives.c).toBeDefined()
-  })
-})
diff --git a/1.Vue/test/unit/features/options/name.spec.js b/1.Vue/test/unit/features/options/name.spec.js
deleted file mode 100644
index 051ea40..0000000
--- a/1.Vue/test/unit/features/options/name.spec.js
+++ /dev/null
@@ -1,48 +0,0 @@
-import Vue from 'vue'
-
-describe('Options name', () => {
-  it('should contain itself in self components', () => {
-    const vm = Vue.extend({
-      name: 'SuperVue'
-    })
-
-    expect(vm.options.components['SuperVue']).toEqual(vm)
-  })
-
-  it('should warn when incorrect name given', () => {
-    Vue.extend({
-      name: 'Hyper*Vue'
-    })
-
-    /* eslint-disable */
-    expect(`Invalid component name: "Hyper*Vue".`)
-      .toHaveBeenWarned()
-    /* eslint-enable */
-
-    Vue.extend({
-      name: '2Cool2BValid'
-    })
-
-    /* eslint-disable */
-    expect(`Invalid component name: "2Cool2BValid".`)
-      .toHaveBeenWarned()
-    /* eslint-enable */
-  })
-
-  it('id should not override given name when using Vue.component', () => {
-    const SuperComponent = Vue.component('super-component', {
-      name: 'SuperVue'
-    })
-
-    expect(SuperComponent.options.components['SuperVue']).toEqual(SuperComponent)
-    expect(SuperComponent.options.components['super-component']).toEqual(SuperComponent)
-  })
-
-  it('should allow all potential custom element name for component name including non-alphanumeric characters', () => {
-    Vue.extend({
-      name: 'my-컴포넌트'
-    })
-
-    expect(`Invalid component name`).not.toHaveBeenWarned()
-  })
-})
diff --git a/1.Vue/test/unit/features/options/parent.spec.js b/1.Vue/test/unit/features/options/parent.spec.js
deleted file mode 100644
index ac84471..0000000
--- a/1.Vue/test/unit/features/options/parent.spec.js
+++ /dev/null
@@ -1,28 +0,0 @@
-import Vue from 'vue'
-
-describe('Options parent', () => {
-  it('should work', () => {
-    const parent = new Vue({
-      render () {}
-    }).$mount()
-
-    const child = new Vue({
-      parent: parent,
-      render () {}
-    }).$mount()
-
-    // this option is straight-forward
-    // it should register 'parent' as a $parent for 'child'
-    // and push 'child' to $children array on 'parent'
-    expect(child.$options.parent).toBeDefined()
-    expect(child.$options.parent).toEqual(parent)
-    expect(child.$parent).toBeDefined()
-    expect(child.$parent).toEqual(parent)
-    expect(parent.$children).toContain(child)
-
-    // destroy 'child' and check if it was removed from 'parent' $children
-    child.$destroy()
-    expect(parent.$children.length).toEqual(0)
-    parent.$destroy()
-  })
-})
diff --git a/1.Vue/test/unit/features/options/props.spec.js b/1.Vue/test/unit/features/options/props.spec.js
deleted file mode 100644
index 5adedeb..0000000
--- a/1.Vue/test/unit/features/options/props.spec.js
+++ /dev/null
@@ -1,546 +0,0 @@
-import Vue from 'vue'
-import { hasSymbol } from 'core/util/env'
-import testObjectOption from '../../../helpers/test-object-option'
-
-describe('Options props', () => {
-  testObjectOption('props')
-
-  it('array syntax', done => {
-    const vm = new Vue({
-      data: {
-        b: 'bar'
-      },
-      template: '<test v-bind:b="b" ref="child"></test>',
-      components: {
-        test: {
-          props: ['b'],
-          template: '<div>{{b}}</div>'
-        }
-      }
-    }).$mount()
-    expect(vm.$el.innerHTML).toBe('bar')
-    vm.b = 'baz'
-    waitForUpdate(() => {
-      expect(vm.$el.innerHTML).toBe('baz')
-      vm.$refs.child.b = 'qux'
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('qux')
-      expect('Avoid mutating a prop directly').toHaveBeenWarned()
-    }).then(done)
-  })
-
-  it('object syntax', done => {
-    const vm = new Vue({
-      data: {
-        b: 'bar'
-      },
-      template: '<test v-bind:b="b" ref="child"></test>',
-      components: {
-        test: {
-          props: { b: String },
-          template: '<div>{{b}}</div>'
-        }
-      }
-    }).$mount()
-    expect(vm.$el.innerHTML).toBe('bar')
-    vm.b = 'baz'
-    waitForUpdate(() => {
-      expect(vm.$el.innerHTML).toBe('baz')
-      vm.$refs.child.b = 'qux'
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('qux')
-      expect('Avoid mutating a prop directly').toHaveBeenWarned()
-    }).then(done)
-  })
-
-  it('warn mixed syntax', () => {
-    new Vue({
-      props: [{ b: String }]
-    })
-    expect('props must be strings when using array syntax').toHaveBeenWarned()
-  })
-
-  it('default values', () => {
-    const vm = new Vue({
-      data: {
-        b: undefined
-      },
-      template: '<test :b="b"></test>',
-      components: {
-        test: {
-          props: {
-            a: {
-              default: 'A' // absent
-            },
-            b: {
-              default: 'B' // undefined
-            }
-          },
-          template: '<div>{{a}}{{b}}</div>'
-        }
-      }
-    }).$mount()
-    expect(vm.$el.textContent).toBe('AB')
-  })
-
-  it('default value reactivity', done => {
-    const vm = new Vue({
-      props: {
-        a: {
-          default: () => ({ b: 1 })
-        }
-      },
-      propsData: {
-        a: undefined
-      },
-      template: '<div>{{ a.b }}</div>'
-    }).$mount()
-    expect(vm.$el.textContent).toBe('1')
-    vm.a.b = 2
-    waitForUpdate(() => {
-      expect(vm.$el.textContent).toBe('2')
-    }).then(done)
-  })
-
-  it('default value Function', () => {
-    const func = () => 132
-    const vm = new Vue({
-      props: {
-        a: {
-          type: Function,
-          default: func
-        }
-      },
-      propsData: {
-        a: undefined
-      }
-    })
-    expect(vm.a).toBe(func)
-  })
-
-  it('warn object/array default values', () => {
-    new Vue({
-      props: {
-        a: {
-          default: { b: 1 }
-        }
-      },
-      propsData: {
-        a: undefined
-      }
-    })
-    expect('Props with type Object/Array must use a factory function').toHaveBeenWarned()
-  })
-
-  it('warn missing required', () => {
-    new Vue({
-      template: '<test></test>',
-      components: {
-        test: {
-          props: { a: { required: true }},
-          template: '<div>{{a}}</div>'
-        }
-      }
-    }).$mount()
-    expect('Missing required prop: "a"').toHaveBeenWarned()
-  })
-
-  describe('assertions', () => {
-    function makeInstance (value, type, validator, required) {
-      return new Vue({
-        template: '<test :test="val"></test>',
-        data: {
-          val: value
-        },
-        components: {
-          test: {
-            template: '<div></div>',
-            props: {
-              test: {
-                type,
-                validator,
-                required
-              }
-            }
-          }
-        }
-      }).$mount()
-    }
-
-    it('string', () => {
-      makeInstance('hello', String)
-      expect(console.error.calls.count()).toBe(0)
-      makeInstance(123, String)
-      expect('Expected String with value "123", got Number with value 123').toHaveBeenWarned()
-    })
-
-    it('number', () => {
-      makeInstance(123, Number)
-      expect(console.error.calls.count()).toBe(0)
-      makeInstance('123', Number)
-      expect('Expected Number with value 123, got String with value "123"').toHaveBeenWarned()
-    })
-
-    it('number & boolean', () => {
-      makeInstance(123, Number)
-      expect(console.error.calls.count()).toBe(0)
-      makeInstance(false, Number)
-      expect('Expected Number, got Boolean with value false').toHaveBeenWarned()
-    })
-
-    it('string & boolean', () => {
-      makeInstance('hello', String)
-      expect(console.error.calls.count()).toBe(0)
-      makeInstance(true, String)
-      expect('Expected String, got Boolean with value true').toHaveBeenWarned()
-    })
-
-    it('boolean', () => {
-      makeInstance(true, Boolean)
-      expect(console.error.calls.count()).toBe(0)
-      makeInstance('123', Boolean)
-      expect('Expected Boolean, got String with value "123"').toHaveBeenWarned()
-    })
-
-    it('function', () => {
-      makeInstance(() => {}, Function)
-      expect(console.error.calls.count()).toBe(0)
-      makeInstance(123, Function)
-      expect('Expected Function, got Number with value 123').toHaveBeenWarned()
-    })
-
-    it('object', () => {
-      makeInstance({}, Object)
-      expect(console.error.calls.count()).toBe(0)
-      makeInstance([], Object)
-      expect('Expected Object, got Array').toHaveBeenWarned()
-    })
-
-    it('array', () => {
-      makeInstance([], Array)
-      expect(console.error.calls.count()).toBe(0)
-      makeInstance({}, Array)
-      expect('Expected Array, got Object').toHaveBeenWarned()
-    })
-
-    it('primitive wrapper objects', () => {
-      /* eslint-disable no-new-wrappers */
-      makeInstance(new String('s'), String)
-      expect(console.error.calls.count()).toBe(0)
-      makeInstance(new Number(1), Number)
-      expect(console.error.calls.count()).toBe(0)
-      makeInstance(new Boolean(true), Boolean)
-      expect(console.error.calls.count()).toBe(0)
-      /* eslint-enable no-new-wrappers */
-    })
-
-    if (hasSymbol) {
-      it('symbol', () => {
-        makeInstance(Symbol('foo'), Symbol)
-        expect(console.error.calls.count()).toBe(0)
-        makeInstance({}, Symbol)
-        expect('Expected Symbol, got Object').toHaveBeenWarned()
-      })
-    }
-
-    it('custom constructor', () => {
-      function Class () {}
-      makeInstance(new Class(), Class)
-      expect(console.error.calls.count()).toBe(0)
-      makeInstance({}, Class)
-      expect('type check failed').toHaveBeenWarned()
-    })
-
-    it('multiple types', () => {
-      makeInstance([], [Array, Number, Boolean])
-      expect(console.error.calls.count()).toBe(0)
-      makeInstance({}, [Array, Number, Boolean])
-      expect('Expected Array, Number, Boolean, got Object').toHaveBeenWarned()
-    })
-
-    it('custom validator', () => {
-      makeInstance(123, null, v => v === 123)
-      expect(console.error.calls.count()).toBe(0)
-      makeInstance(123, null, v => v === 234)
-      expect('custom validator check failed').toHaveBeenWarned()
-    })
-
-    it('type check + custom validator', () => {
-      makeInstance(123, Number, v => v === 123)
-      expect(console.error.calls.count()).toBe(0)
-      makeInstance(123, Number, v => v === 234)
-      expect('custom validator check failed').toHaveBeenWarned()
-      makeInstance(123, String, v => v === 123)
-      expect('Expected String with value "123", got Number with value 123').toHaveBeenWarned()
-    })
-
-    it('multiple types + custom validator', () => {
-      makeInstance(123, [Number, String, Boolean], v => v === 123)
-      expect(console.error.calls.count()).toBe(0)
-      makeInstance(123, [Number, String, Boolean], v => v === 234)
-      expect('custom validator check failed').toHaveBeenWarned()
-      makeInstance(123, [String, Boolean], v => v === 123)
-      expect('Expected String, Boolean').toHaveBeenWarned()
-    })
-
-    it('optional with type + null/undefined', () => {
-      makeInstance(undefined, String)
-      expect(console.error.calls.count()).toBe(0)
-      makeInstance(null, String)
-      expect(console.error.calls.count()).toBe(0)
-    })
-
-    it('required with type + null/undefined', () => {
-      makeInstance(undefined, String, null, true)
-      expect(console.error.calls.count()).toBe(1)
-      expect('Expected String').toHaveBeenWarned()
-      makeInstance(null, Boolean, null, true)
-      expect(console.error.calls.count()).toBe(2)
-      expect('Expected Boolean').toHaveBeenWarned()
-    })
-
-    it('optional prop of any type (type: true or prop: true)', () => {
-      makeInstance(1, true)
-      expect(console.error.calls.count()).toBe(0)
-      makeInstance('any', true)
-      expect(console.error.calls.count()).toBe(0)
-      makeInstance({}, true)
-      expect(console.error.calls.count()).toBe(0)
-      makeInstance(undefined, true)
-      expect(console.error.calls.count()).toBe(0)
-      makeInstance(null, true)
-      expect(console.error.calls.count()).toBe(0)
-    })
-  })
-
-  it('should work with v-bind', () => {
-    const vm = new Vue({
-      template: `<test v-bind="{ a: 1, b: 2 }"></test>`,
-      components: {
-        test: {
-          props: ['a', 'b'],
-          template: '<div>{{ a }} {{ b }}</div>'
-        }
-      }
-    }).$mount()
-    expect(vm.$el.textContent).toBe('1 2')
-  })
-
-  it('should warn data fields already defined as a prop', () => {
-    new Vue({
-      template: '<test a="1"></test>',
-      components: {
-        test: {
-          template: '<div></div>',
-          data: function () {
-            return { a: 123 }
-          },
-          props: {
-            a: null
-          }
-        }
-      }
-    }).$mount()
-    expect('already declared as a prop').toHaveBeenWarned()
-  })
-
-  it('should warn methods already defined as a prop', () => {
-    new Vue({
-      template: '<test a="1"></test>',
-      components: {
-        test: {
-          template: '<div></div>',
-          props: {
-            a: null
-          },
-          methods: {
-            a () {
-
-            }
-          }
-        }
-      }
-    }).$mount()
-    expect(`Method "a" has already been defined as a prop`).toHaveBeenWarned()
-    expect(`Avoid mutating a prop directly`).toHaveBeenWarned()
-  })
-
-  it('treat boolean props properly', () => {
-    const vm = new Vue({
-      template: '<comp ref="child" prop-a prop-b="prop-b"></comp>',
-      components: {
-        comp: {
-          template: '<div></div>',
-          props: {
-            propA: Boolean,
-            propB: Boolean,
-            propC: Boolean
-          }
-        }
-      }
-    }).$mount()
-    expect(vm.$refs.child.propA).toBe(true)
-    expect(vm.$refs.child.propB).toBe(true)
-    expect(vm.$refs.child.propC).toBe(false)
-  })
-
-  it('should respect default value of a Boolean prop', function () {
-    const vm = new Vue({
-      template: '<test></test>',
-      components: {
-        test: {
-          props: {
-            prop: {
-              type: Boolean,
-              default: true
-            }
-          },
-          template: '<div>{{prop}}</div>'
-        }
-      }
-    }).$mount()
-    expect(vm.$el.textContent).toBe('true')
-  })
-
-  it('non reactive values passed down as prop should not be converted', done => {
-    const a = Object.freeze({
-      nested: {
-        msg: 'hello'
-      }
-    })
-    const parent = new Vue({
-      template: '<comp :a="a.nested"></comp>',
-      data: {
-        a: a
-      },
-      components: {
-        comp: {
-          template: '<div></div>',
-          props: ['a']
-        }
-      }
-    }).$mount()
-    const child = parent.$children[0]
-    expect(child.a.msg).toBe('hello')
-    expect(child.a.__ob__).toBeUndefined() // should not be converted
-    parent.a = Object.freeze({
-      nested: {
-        msg: 'yo'
-      }
-    })
-    waitForUpdate(() => {
-      expect(child.a.msg).toBe('yo')
-      expect(child.a.__ob__).toBeUndefined()
-    }).then(done)
-  })
-
-  it('should not warn for non-required, absent prop', function () {
-    new Vue({
-      template: '<test></test>',
-      components: {
-        test: {
-          template: '<div></div>',
-          props: {
-            prop: {
-              type: String
-            }
-          }
-        }
-      }
-    }).$mount()
-    expect(console.error.calls.count()).toBe(0)
-  })
-
-  // #3453
-  it('should not fire watcher on object/array props when parent re-renders', done => {
-    const spy = jasmine.createSpy()
-    const vm = new Vue({
-      data: {
-        arr: []
-      },
-      template: '<test :prop="arr">hi</test>',
-      components: {
-        test: {
-          props: ['prop'],
-          watch: {
-            prop: spy
-          },
-          template: '<div><slot></slot></div>'
-        }
-      }
-    }).$mount()
-    vm.$forceUpdate()
-    waitForUpdate(() => {
-      expect(spy).not.toHaveBeenCalled()
-    }).then(done)
-  })
-
-  // #4090
-  it('should not trigger watcher on default value', done => {
-    const spy = jasmine.createSpy()
-    const vm = new Vue({
-      template: `<test :value="a" :test="b"></test>`,
-      data: {
-        a: 1,
-        b: undefined
-      },
-      components: {
-        test: {
-          template: '<div>{{ value }}</div>',
-          props: {
-            value: { type: Number },
-            test: {
-              type: Object,
-              default: () => ({})
-            }
-          },
-          watch: {
-            test: spy
-          }
-        }
-      }
-    }).$mount()
-
-    vm.a++
-    waitForUpdate(() => {
-      expect(spy).not.toHaveBeenCalled()
-      vm.b = {}
-    }).then(() => {
-      expect(spy.calls.count()).toBe(1)
-    }).then(() => {
-      vm.b = undefined
-    }).then(() => {
-      expect(spy.calls.count()).toBe(2)
-      vm.a++
-    }).then(() => {
-      expect(spy.calls.count()).toBe(2)
-    }).then(done)
-  })
-
-  it('warn reserved props', () => {
-    const specialAttrs = ['key', 'ref', 'slot', 'is', 'slot-scope']
-    new Vue({
-      props: specialAttrs
-    })
-    specialAttrs.forEach(attr => {
-      expect(`"${attr}" is a reserved attribute`).toHaveBeenWarned()
-    })
-  })
-
-  it('should consider order when casting [Boolean, String] multi-type props', () => {
-    const vm = new Vue({
-      template: '<test ref="test" booleanOrString stringOrBoolean />',
-      components: {
-        test: {
-          template: '<div></div>',
-          props: {
-            booleanOrString: [Boolean, String],
-            stringOrBoolean: [String, Boolean]
-          }
-        }
-      }
-    }).$mount()
-    expect(vm.$refs.test.$props.booleanOrString).toBe(true)
-    expect(vm.$refs.test.$props.stringOrBoolean).toBe('')
-  })
-})
diff --git a/1.Vue/test/unit/features/options/propsData.spec.js b/1.Vue/test/unit/features/options/propsData.spec.js
deleted file mode 100644
index 9fa5557..0000000
--- a/1.Vue/test/unit/features/options/propsData.spec.js
+++ /dev/null
@@ -1,30 +0,0 @@
-import Vue from 'vue'
-
-describe('Options propsData', () => {
-  it('should work', done => {
-    const A = Vue.extend({
-      props: ['a'],
-      template: '<div>{{ a }}</div>'
-    })
-    const vm = new A({
-      propsData: {
-        a: 123
-      }
-    }).$mount()
-    expect(vm.a).toBe(123)
-    expect(vm.$el.textContent).toBe('123')
-    vm.a = 234
-    waitForUpdate(() => {
-      expect(vm.$el.textContent).toBe('234')
-    }).then(done)
-  })
-
-  it('warn non instantiation usage', () => {
-    Vue.extend({
-      propsData: {
-        a: 123
-      }
-    })
-    expect('option "propsData" can only be used during instance creation').toHaveBeenWarned()
-  })
-})
diff --git a/1.Vue/test/unit/features/options/render.spec.js b/1.Vue/test/unit/features/options/render.spec.js
deleted file mode 100644
index 302e2ee..0000000
--- a/1.Vue/test/unit/features/options/render.spec.js
+++ /dev/null
@@ -1,39 +0,0 @@
-import Vue from 'vue'
-
-describe('Options render', () => {
-  it('basic usage', () => {
-    const vm = new Vue({
-      render (h) {
-        const children = []
-        for (let i = 0; i < this.items.length; i++) {
-          children.push(h('li', { staticClass: 'task' }, [this.items[i].name]))
-        }
-        return h('ul', { staticClass: 'tasks' }, children)
-      },
-      data: {
-        items: [{ id: 1, name: 'task1' }, { id: 2, name: 'task2' }]
-      }
-    }).$mount()
-    expect(vm.$el.tagName).toBe('UL')
-    for (let i = 0; i < vm.$el.children.length; i++) {
-      const li = vm.$el.children[i]
-      expect(li.tagName).toBe('LI')
-      expect(li.textContent).toBe(vm.items[i].name)
-    }
-  })
-
-  it('allow null data', () => {
-    const vm = new Vue({
-      render (h) {
-        return h('div', null, 'hello' /* string as children*/)
-      }
-    }).$mount()
-    expect(vm.$el.tagName).toBe('DIV')
-    expect(vm.$el.textContent).toBe('hello')
-  })
-
-  it('should warn non `render` option and non `template` option', () => {
-    new Vue().$mount()
-    expect('Failed to mount component: template or render function not defined.').toHaveBeenWarned()
-  })
-})
diff --git a/1.Vue/test/unit/features/options/renderError.spec.js b/1.Vue/test/unit/features/options/renderError.spec.js
deleted file mode 100644
index 20a0aa7..0000000
--- a/1.Vue/test/unit/features/options/renderError.spec.js
+++ /dev/null
@@ -1,42 +0,0 @@
-import Vue from 'vue'
-
-describe('Options renderError', () => {
-  it('should be used on render errors', done => {
-    Vue.config.errorHandler = () => {}
-    const vm = new Vue({
-      data: {
-        ok: true
-      },
-      render (h) {
-        if (this.ok) {
-          return h('div', 'ok')
-        } else {
-          throw new Error('no')
-        }
-      },
-      renderError (h, err) {
-        return h('div', err.toString())
-      }
-    }).$mount()
-    expect(vm.$el.textContent).toBe('ok')
-    vm.ok = false
-    waitForUpdate(() => {
-      expect(vm.$el.textContent).toBe('Error: no')
-      Vue.config.errorHandler = null
-    }).then(done)
-  })
-
-  it('should pass on errors in renderError to global handler', () => {
-    const spy = Vue.config.errorHandler = jasmine.createSpy()
-    const err = new Error('renderError')
-    const vm = new Vue({
-      render () {
-        throw new Error('render')
-      },
-      renderError () {
-        throw err
-      }
-    }).$mount()
-    expect(spy).toHaveBeenCalledWith(err, vm, 'renderError')
-  })
-})
diff --git a/1.Vue/test/unit/features/options/template.spec.js b/1.Vue/test/unit/features/options/template.spec.js
deleted file mode 100644
index 09aafd3..0000000
--- a/1.Vue/test/unit/features/options/template.spec.js
+++ /dev/null
@@ -1,91 +0,0 @@
-import Vue from 'vue'
-
-describe('Options template', () => {
-  let el
-  beforeEach(() => {
-    el = document.createElement('script')
-    el.type = 'x-template'
-    el.id = 'app'
-    el.innerHTML = '<p>{{message}}</p>'
-    document.body.appendChild(el)
-  })
-
-  afterEach(() => {
-    document.body.removeChild(el)
-  })
-
-  it('basic usage', () => {
-    const vm = new Vue({
-      template: '<div>{{message}}</div>',
-      data: { message: 'hello world' }
-    }).$mount()
-    expect(vm.$el.tagName).toBe('DIV')
-    expect(vm.$el.textContent).toBe(vm.message)
-  })
-
-  it('id reference', () => {
-    const vm = new Vue({
-      template: '#app',
-      data: { message: 'hello world' }
-    }).$mount()
-    expect(vm.$el.tagName).toBe('P')
-    expect(vm.$el.textContent).toBe(vm.message)
-  })
-
-  it('DOM element', () => {
-    const elm = document.createElement('p')
-    elm.innerHTML = '<p>{{message}}</p>'
-    const vm = new Vue({
-      template: elm,
-      data: { message: 'hello world' }
-    }).$mount()
-    expect(vm.$el.tagName).toBe('P')
-    expect(vm.$el.textContent).toBe(vm.message)
-  })
-
-  it('invalid template', () => {
-    new Vue({
-      template: Vue,
-      data: { message: 'hello world' }
-    }).$mount()
-    expect('invalid template option').toHaveBeenWarned()
-  })
-
-  it('warn error in generated function', () => {
-    new Vue({
-      template: '<div v-if="!@"><span>{{ a"" }}</span><span>{{ do + 1 }}</span></div>'
-    }).$mount()
-    expect('Error compiling template').toHaveBeenWarned()
-    expect('Raw expression: v-if="!@"').toHaveBeenWarned()
-    expect('Raw expression: {{ a"" }}').toHaveBeenWarned()
-    expect('avoid using JavaScript keyword as property name: "do"').toHaveBeenWarned()
-  })
-
-  it('should not warn $ prefixed keywords', () => {
-    new Vue({
-      template: `<div @click="$delete(foo, 'bar')"></div>`
-    }).$mount()
-    expect('avoid using JavaScript keyword as property name').not.toHaveBeenWarned()
-  })
-
-  it('warn error in generated function (v-for)', () => {
-    new Vue({
-      template: '<div><div v-for="(1, 2) in a----"></div></div>'
-    }).$mount()
-    expect('Error compiling template').toHaveBeenWarned()
-    expect('invalid v-for alias "1"').toHaveBeenWarned()
-    expect('invalid v-for iterator "2"').toHaveBeenWarned()
-    expect('Raw expression: v-for="(1, 2) in a----"').toHaveBeenWarned()
-  })
-
-  it('warn error in generated function (v-on)', () => {
-    new Vue({
-      template: `<div @click="delete('Delete')"></div>`,
-      methods: { delete: function () {} }
-    }).$mount()
-    expect('Error compiling template').toHaveBeenWarned()
-    expect(
-      `avoid using JavaScript unary operator as property name: "delete()" in expression @click="delete('Delete')"`
-    ).toHaveBeenWarned()
-  })
-})
diff --git a/1.Vue/test/unit/features/options/watch.spec.js b/1.Vue/test/unit/features/options/watch.spec.js
deleted file mode 100644
index 3938bd3..0000000
--- a/1.Vue/test/unit/features/options/watch.spec.js
+++ /dev/null
@@ -1,178 +0,0 @@
-import Vue from 'vue'
-import testObjectOption from '../../../helpers/test-object-option'
-import { finished } from 'stream';
-
-describe('Options watch', () => {
-  let spy
-  beforeEach(() => {
-    spy = jasmine.createSpy('watch')
-  })
-
-  testObjectOption('watch')
-
-  it('basic usage', done => {
-    const vm = new Vue({
-      data: {
-        a: 1
-      },
-      watch: {
-        a: spy
-      }
-    })
-    expect(spy).not.toHaveBeenCalled()
-    vm.a = 2
-    expect(spy).not.toHaveBeenCalled()
-    waitForUpdate(() => {
-      expect(spy).toHaveBeenCalledWith(2, 1)
-    }).then(done)
-  })
-
-  it('string method name', done => {
-    const vm = new Vue({
-      data: {
-        a: 1
-      },
-      watch: {
-        a: 'onChange'
-      },
-      methods: {
-        onChange: spy
-      }
-    })
-    expect(spy).not.toHaveBeenCalled()
-    vm.a = 2
-    expect(spy).not.toHaveBeenCalled()
-    waitForUpdate(() => {
-      expect(spy).toHaveBeenCalledWith(2, 1)
-    }).then(done)
-  })
-
-  it('multiple cbs (after option merge)', done => {
-    const spy1 = jasmine.createSpy('watch')
-    const Test = Vue.extend({
-      watch: {
-        a: spy1
-      }
-    })
-    const vm = new Test({
-      data: { a: 1 },
-      watch: {
-        a: spy
-      }
-    })
-    vm.a = 2
-    waitForUpdate(() => {
-      expect(spy1).toHaveBeenCalledWith(2, 1)
-      expect(spy).toHaveBeenCalledWith(2, 1)
-    }).then(done)
-  })
-
-  it('with option: immediate', done => {
-    const vm = new Vue({
-      data: { a: 1 },
-      watch: {
-        a: {
-          handler: spy,
-          immediate: true
-        }
-      }
-    })
-    expect(spy).toHaveBeenCalledWith(1)
-    vm.a = 2
-    waitForUpdate(() => {
-      expect(spy).toHaveBeenCalledWith(2, 1)
-    }).then(done)
-  })
-
-  it('with option: deep', done => {
-    const vm = new Vue({
-      data: { a: { b: 1 }},
-      watch: {
-        a: {
-          handler: spy,
-          deep: true
-        }
-      }
-    })
-    const oldA = vm.a
-    expect(spy).not.toHaveBeenCalled()
-    vm.a.b = 2
-    expect(spy).not.toHaveBeenCalled()
-    waitForUpdate(() => {
-      expect(spy).toHaveBeenCalledWith(vm.a, vm.a)
-      vm.a = { b: 3 }
-    }).then(() => {
-      expect(spy).toHaveBeenCalledWith(vm.a, oldA)
-    }).then(done)
-  })
-
-  it('correctly merges multiple extends', done => {
-    const spy2 = jasmine.createSpy('A')
-    const spy3 = jasmine.createSpy('B')
-    const A = Vue.extend({
-      data: function () {
-        return {
-          a: 0,
-          b: 0
-        }
-      },
-      watch: {
-        b: spy
-      }
-    })
-
-    const B = Vue.extend({
-      extends: A,
-      watch: {
-        a: spy2
-      }
-    })
-
-    const C = Vue.extend({
-      extends: B,
-      watch: {
-        a: spy3
-      }
-    })
-
-    const vm = new C()
-    vm.a = 1
-
-    waitForUpdate(() => {
-      expect(spy).not.toHaveBeenCalled()
-      expect(spy2).toHaveBeenCalledWith(1, 0)
-      expect(spy3).toHaveBeenCalledWith(1, 0)
-    }).then(done)
-  })
-
-  it('should support watching unicode paths', done => {
-    const vm = new Vue({
-      data: {
-        数据: 1
-      },
-      watch: {
-        数据: spy
-      }
-    })
-    expect(spy).not.toHaveBeenCalled()
-    vm['数据'] = 2
-    expect(spy).not.toHaveBeenCalled()
-    waitForUpdate(() => {
-      expect(spy).toHaveBeenCalledWith(2, 1)
-    }).then(done)
-  })
-
-  it('should not warn proper usage', () => {
-    const vm = new Vue({
-      data: {
-        foo: { _bar: 1 }, // element has such watchers...
-        prop1: 123
-      },
-      watch: {
-        'foo._bar': () => {},
-        prop1 () {}
-      }
-    })
-    expect(`Failed watching path`).not.toHaveBeenWarned()
-  })
-})
diff --git a/1.Vue/test/unit/features/ref.spec.js b/1.Vue/test/unit/features/ref.spec.js
deleted file mode 100644
index 971c8fb..0000000
--- a/1.Vue/test/unit/features/ref.spec.js
+++ /dev/null
@@ -1,227 +0,0 @@
-import Vue from 'vue'
-
-describe('ref', () => {
-  const components = {
-    test: {
-      id: 'test',
-      template: '<div>test</div>'
-    },
-    test2: {
-      id: 'test2',
-      template: '<div>test2</div>'
-    },
-    test3: {
-      id: 'test3',
-      template: '<div>test3</div>'
-    }
-  }
-
-  it('should work', () => {
-    const vm = new Vue({
-      data: {
-        value: 'bar'
-      },
-      template: `<div>
-        <test ref="foo"></test>
-        <test2 :ref="value"></test2>
-        <test3 :ref="0"></test3>
-      </div>`,
-      components
-    })
-    vm.$mount()
-    expect(vm.$refs.foo).toBeTruthy()
-    expect(vm.$refs.foo.$options.id).toBe('test')
-    expect(vm.$refs.bar).toBeTruthy()
-    expect(vm.$refs.bar.$options.id).toBe('test2')
-    expect(vm.$refs['0']).toBeTruthy()
-    expect(vm.$refs['0'].$options.id).toBe('test3')
-  })
-
-  it('should dynamically update refs', done => {
-    const vm = new Vue({
-      data: {
-        value: 'foo'
-      },
-      template: '<div :ref="value"></div>'
-    }).$mount()
-    expect(vm.$refs.foo).toBe(vm.$el)
-    vm.value = 'bar'
-    waitForUpdate(() => {
-      expect(vm.$refs.foo).toBeUndefined()
-      expect(vm.$refs.bar).toBe(vm.$el)
-    }).then(done)
-  })
-
-  it('should work as a hyperscript prop', () => {
-    const vm = new Vue({
-      components,
-      render (h) {
-        return h('div', null, [
-          h('test', { ref: 'test' })
-        ])
-      }
-    })
-    vm.$mount()
-    expect(vm.$refs.test).toBeTruthy()
-    expect(vm.$refs.test.$options.id).toBe('test')
-  })
-
-  it('should accept HOC component', () => {
-    const vm = new Vue({
-      template: '<test ref="test"></test>',
-      components
-    })
-    vm.$mount()
-    expect(vm.$refs.test).toBeTruthy()
-    expect(vm.$refs.test.$options.id).toBe('test')
-  })
-
-  it('should accept dynamic component', done => {
-    const vm = new Vue({
-      template: `<div>
-        <component :is="test" ref="test"></component>
-      </div>`,
-      components,
-      data: { test: 'test' }
-    })
-    vm.$mount()
-    expect(vm.$refs.test.$options.id).toBe('test')
-    vm.test = 'test2'
-    waitForUpdate(() => {
-      expect(vm.$refs.test.$options.id).toBe('test2')
-      vm.test = ''
-    }).then(() => {
-      expect(vm.$refs.test).toBeUndefined()
-    }).then(done)
-  })
-
-  it('should register as Array when used with v-for', done => {
-    const vm = new Vue({
-      data: {
-        items: [1, 2, 3]
-      },
-      template: `
-        <div>
-          <div v-for="n in items" ref="list">{{n}}</div>
-        </div>
-      `
-    }).$mount()
-    assertRefs()
-    // updating
-    vm.items.push(4)
-    waitForUpdate(assertRefs)
-      .then(() => { vm.items = [] })
-      .then(assertRefs)
-      .then(done)
-
-    function assertRefs () {
-      expect(Array.isArray(vm.$refs.list)).toBe(true)
-      expect(vm.$refs.list.length).toBe(vm.items.length)
-      expect(vm.$refs.list.every((item, i) => item.textContent === String(i + 1))).toBe(true)
-    }
-  })
-
-  it('should register as Array when used with v-for (components)', done => {
-    const vm = new Vue({
-      data: {
-        items: [1, 2, 3]
-      },
-      template: `
-        <div>
-          <test v-for="n in items" ref="list" :key="n" :n="n"></test>
-        </div>
-      `,
-      components: {
-        test: {
-          props: ['n'],
-          template: '<div>{{ n }}</div>'
-        }
-      }
-    }).$mount()
-    assertRefs()
-    // updating
-    vm.items.push(4)
-    waitForUpdate(assertRefs)
-      .then(() => { vm.items = [] })
-      .then(assertRefs)
-      .then(done)
-
-    function assertRefs () {
-      expect(Array.isArray(vm.$refs.list)).toBe(true)
-      expect(vm.$refs.list.length).toBe(vm.items.length)
-      expect(vm.$refs.list.every((comp, i) => comp.$el.textContent === String(i + 1))).toBe(true)
-    }
-  })
-
-  it('should work with v-for on dynamic component', done => {
-    components.test3 = {
-      id: 'test3',
-      template: `<test1 v-if="!normal"></test1><div v-else>test3</div>`,
-      data () {
-        return { normal: false }
-      },
-      components: { test1: components.test }
-    }
-    // a flag that representing whether to test component content or not
-    let testContent = false
-
-    const vm = new Vue({
-      template: `
-        <div>
-          <component
-            v-for="(item, index) in items"
-            :key="index"
-            :is="item"
-            ref="children">
-          </component>
-        </div>
-      `,
-      data: {
-        items: ['test2', 'test3']
-      },
-      components
-    }).$mount()
-    assertRefs()
-    expect(vm.$refs.children[0].$el.textContent).toBe('test2')
-    expect(vm.$refs.children[1].$el.textContent).toBe('test')
-    // updating
-    vm.$refs.children[1].normal = true
-    testContent = true
-    waitForUpdate(assertRefs)
-      .then(() => { vm.items.push('test') })
-      .then(assertRefs)
-      .then(done)
-
-    function assertRefs () {
-      expect(Array.isArray(vm.$refs.children)).toBe(true)
-      expect(vm.$refs.children.length).toBe(vm.items.length)
-      if (testContent) {
-        expect(
-          vm.$refs.children.every((comp, i) => comp.$el.textContent === vm.items[i])
-        ).toBe(true)
-      }
-    }
-  })
-
-  it('should register on component with empty roots', done => {
-    const vm = new Vue({
-      template: '<child ref="test"></child>',
-      components: {
-        child: {
-          template: '<div v-if="show"></div>',
-          data () {
-            return { show: false }
-          }
-        }
-      }
-    }).$mount()
-    expect(vm.$refs.test).toBe(vm.$children[0])
-    vm.$refs.test.show = true
-    waitForUpdate(() => {
-      expect(vm.$refs.test).toBe(vm.$children[0])
-      vm.$refs.test.show = false
-    }).then(() => {
-      expect(vm.$refs.test).toBe(vm.$children[0])
-    }).then(done)
-  })
-})
diff --git a/1.Vue/test/unit/features/transition/inject-styles.js b/1.Vue/test/unit/features/transition/inject-styles.js
deleted file mode 100644
index 3418509..0000000
--- a/1.Vue/test/unit/features/transition/inject-styles.js
+++ /dev/null
@@ -1,64 +0,0 @@
-function insertCSS (text) {
-  const cssEl = document.createElement('style')
-  cssEl.textContent = text.trim()
-  document.head.appendChild(cssEl)
-}
-
-const duration = process.env.TRANSITION_DURATION || 50
-const buffer = process.env.TRANSITION_BUFFER || 10
-let injected = false
-
-export default function injectStyles () {
-  if (injected) return { duration, buffer }
-  injected = true
-  insertCSS(`
-    .test {
-      -webkit-transition: opacity ${duration}ms ease;
-      transition: opacity ${duration}ms ease;
-    }
-    .group-move {
-      -webkit-transition: -webkit-transform ${duration}ms ease;
-      transition: transform ${duration}ms ease;
-    }
-    .v-appear, .v-enter, .v-leave-active,
-    .test-appear, .test-enter, .test-leave-active,
-    .hello, .bye.active,
-    .changed-enter {
-      opacity: 0;
-    }
-    .test-anim-enter-active {
-      animation: test-enter ${duration}ms;
-      -webkit-animation: test-enter ${duration}ms;
-    }
-    .test-anim-leave-active {
-      animation: test-leave ${duration}ms;
-      -webkit-animation: test-leave ${duration}ms;
-    }
-    .test-anim-long-enter-active {
-      animation: test-enter ${duration * 2}ms;
-      -webkit-animation: test-enter ${duration * 2}ms;
-    }
-    .test-anim-long-leave-active {
-      animation: test-leave ${duration * 2}ms;
-      -webkit-animation: test-leave ${duration * 2}ms;
-    }
-    @keyframes test-enter {
-      from { opacity: 0 }
-      to { opacity: 1 }
-    }
-    @-webkit-keyframes test-enter {
-      from { opacity: 0 }
-      to { opacity: 1 }
-    }
-    @keyframes test-leave {
-      from { opacity: 1 }
-      to { opacity: 0 }
-    }
-    @-webkit-keyframes test-leave {
-      from { opacity: 1 }
-      to { opacity: 0 }
-    }
-  `)
-  return { duration, buffer }
-}
-
diff --git a/1.Vue/test/unit/features/transition/transition-group.spec.js b/1.Vue/test/unit/features/transition/transition-group.spec.js
deleted file mode 100644
index 2988d5b..0000000
--- a/1.Vue/test/unit/features/transition/transition-group.spec.js
+++ /dev/null
@@ -1,344 +0,0 @@
-import Vue from 'vue'
-import injectStyles from './inject-styles'
-import { isIE9 } from 'core/util/env'
-import { nextFrame } from 'web/runtime/transition-util'
-
-if (!isIE9) {
-  describe('Transition group', () => {
-    const { duration, buffer } = injectStyles()
-
-    let el
-    beforeEach(() => {
-      el = document.createElement('div')
-      document.body.appendChild(el)
-    })
-
-    function createBasicVM (useIs, appear) {
-      const vm = new Vue({
-        template: `
-          <div>
-            ${useIs ? `<span is="transition-group">` : `<transition-group${appear ? ` appear` : ``}>`}
-              <div v-for="item in items" :key="item" class="test">{{ item }}</div>
-            ${useIs ? `</span>` : `</transition-group>`}
-          </div>
-        `,
-        data: {
-          items: ['a', 'b', 'c']
-        }
-      }).$mount(el)
-      if (!appear) {
-        expect(vm.$el.innerHTML).toBe(
-          `<span>` +
-            vm.items.map(i => `<div class="test">${i}</div>`).join('') +
-          `</span>`
-        )
-      }
-      return vm
-    }
-
-    it('enter', done => {
-      const vm = createBasicVM()
-      vm.items.push('d', 'e')
-      waitForUpdate(() => {
-        expect(vm.$el.innerHTML).toBe(
-          `<span>` +
-            ['a', 'b', 'c'].map(i => `<div class="test">${i}</div>`).join('') +
-            `<div class="test v-enter v-enter-active">d</div>` +
-            `<div class="test v-enter v-enter-active">e</div>` +
-          `</span>`
-        )
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          `<span>` +
-            ['a', 'b', 'c'].map(i => `<div class="test">${i}</div>`).join('') +
-            `<div class="test v-enter-active v-enter-to">d</div>` +
-            `<div class="test v-enter-active v-enter-to">e</div>` +
-          `</span>`
-        )
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          `<span>` +
-            vm.items.map(i => `<div class="test">${i}</div>`).join('') +
-          `</span>`
-        )
-      }).then(done)
-    })
-
-    it('leave', done => {
-      const vm = createBasicVM()
-      vm.items = ['b']
-      waitForUpdate(() => {
-        expect(vm.$el.innerHTML).toBe(
-          `<span>` +
-            `<div class="test v-leave v-leave-active">a</div>` +
-            `<div class="test">b</div>` +
-            `<div class="test v-leave v-leave-active">c</div>` +
-          `</span>`
-        )
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          `<span>` +
-            `<div class="test v-leave-active v-leave-to">a</div>` +
-            `<div class="test">b</div>` +
-            `<div class="test v-leave-active v-leave-to">c</div>` +
-          `</span>`
-        )
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          `<span>` +
-            vm.items.map(i => `<div class="test">${i}</div>`).join('') +
-          `</span>`
-        )
-      }).then(done)
-    })
-
-    it('enter + leave', done => {
-      const vm = createBasicVM()
-      vm.items = ['b', 'c', 'd']
-      waitForUpdate(() => {
-        expect(vm.$el.innerHTML).toBe(
-          `<span>` +
-            `<div class="test v-leave v-leave-active">a</div>` +
-            `<div class="test">b</div>` +
-            `<div class="test">c</div>` +
-            `<div class="test v-enter v-enter-active">d</div>` +
-          `</span>`
-        )
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          `<span>` +
-            `<div class="test v-leave-active v-leave-to">a</div>` +
-            `<div class="test">b</div>` +
-            `<div class="test">c</div>` +
-            `<div class="test v-enter-active v-enter-to">d</div>` +
-          `</span>`
-        )
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          `<span>` +
-            vm.items.map(i => `<div class="test">${i}</div>`).join('') +
-          `</span>`
-        )
-      }).then(done)
-    })
-
-    it('use with "is" attribute', done => {
-      const vm = createBasicVM(true)
-      vm.items = ['b', 'c', 'd']
-      waitForUpdate(() => {
-        expect(vm.$el.innerHTML).toBe(
-          `<span>` +
-            `<div class="test v-leave v-leave-active">a</div>` +
-            `<div class="test">b</div>` +
-            `<div class="test">c</div>` +
-            `<div class="test v-enter v-enter-active">d</div>` +
-          `</span>`
-        )
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          `<span>` +
-            `<div class="test v-leave-active v-leave-to">a</div>` +
-            `<div class="test">b</div>` +
-            `<div class="test">c</div>` +
-            `<div class="test v-enter-active v-enter-to">d</div>` +
-          `</span>`
-        )
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          `<span>` +
-            vm.items.map(i => `<div class="test">${i}</div>`).join('') +
-          `</span>`
-        )
-      }).then(done)
-    })
-
-    it('appear', done => {
-      const vm = createBasicVM(false, true /* appear */)
-      waitForUpdate(() => {
-        expect(vm.$el.innerHTML).toBe(
-          `<span>` +
-            vm.items.map(i => `<div class="test v-enter v-enter-active">${i}</div>`).join('') +
-          `</span>`
-        )
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          `<span>` +
-            vm.items.map(i => `<div class="test v-enter-active v-enter-to">${i}</div>`).join('') +
-          `</span>`
-        )
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          `<span>` +
-            vm.items.map(i => `<div class="test">${i}</div>`).join('') +
-          `</span>`
-        )
-      }).then(done)
-    })
-
-    it('events', done => {
-      let next
-      const beforeEnterSpy = jasmine.createSpy()
-      const afterEnterSpy = jasmine.createSpy()
-      const afterLeaveSpy = jasmine.createSpy()
-      const vm = new Vue({
-        template: `
-          <div>
-            <transition-group @before-enter="beforeEnter" @after-enter="afterEnter" @after-leave="afterLeave">
-              <div v-for="item in items" :key="item" class="test">{{ item }}</div>
-            </transition-group>
-          </div>
-        `,
-        data: {
-          items: ['a', 'b', 'c']
-        },
-        methods: {
-          beforeEnter (el) {
-            expect(el.textContent).toBe('d')
-            beforeEnterSpy()
-          },
-          afterEnter (el) {
-            expect(el.textContent).toBe('d')
-            afterEnterSpy()
-            next()
-          },
-          afterLeave (el) {
-            expect(el.textContent).toBe('a')
-            afterLeaveSpy()
-            next()
-          }
-        }
-      }).$mount(el)
-
-      vm.items.push('d')
-      waitForUpdate(() => {
-        expect(vm.$el.innerHTML).toBe(
-          `<span>` +
-            `<div class="test">a</div>` +
-            `<div class="test">b</div>` +
-            `<div class="test">c</div>` +
-            `<div class="test v-enter v-enter-active">d</div>` +
-          `</span>`
-        )
-        expect(beforeEnterSpy.calls.count()).toBe(1)
-      }).thenWaitFor(_next => { next = _next }).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          `<span>` +
-            `<div class="test">a</div>` +
-            `<div class="test">b</div>` +
-            `<div class="test">c</div>` +
-            `<div class="test">d</div>` +
-          `</span>`
-        )
-        expect(afterEnterSpy.calls.count()).toBe(1)
-        vm.items.shift()
-      }).thenWaitFor(_next => { next = _next }).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          `<span>` +
-            `<div class="test">b</div>` +
-            `<div class="test">c</div>` +
-            `<div class="test">d</div>` +
-          `</span>`
-        )
-        expect(afterLeaveSpy.calls.count()).toBe(1)
-      }).then(done)
-    })
-
-    it('move', done => {
-      const vm = new Vue({
-        template: `
-          <div>
-            <transition-group name="group">
-              <div v-for="item in items" :key="item" class="test">{{ item }}</div>
-            </transition-group>
-          </div>
-        `,
-        data: {
-          items: ['a', 'b', 'c']
-        }
-      }).$mount(el)
-
-      vm.items = ['d', 'b', 'a']
-      waitForUpdate(() => {
-        expect(vm.$el.innerHTML.replace(/\s?style=""(\s?)/g, '$1')).toBe(
-          `<span>` +
-            `<div class="test group-enter group-enter-active">d</div>` +
-            `<div class="test">b</div>` +
-            `<div class="test group-move">a</div>` +
-            `<div class="test group-leave group-leave-active group-move">c</div>` +
-          `</span>`
-        )
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML.replace(/\s?style=""(\s?)/g, '$1')).toBe(
-          `<span>` +
-            `<div class="test group-enter-active group-enter-to">d</div>` +
-            `<div class="test">b</div>` +
-            `<div class="test group-move">a</div>` +
-            `<div class="test group-leave-active group-move group-leave-to">c</div>` +
-          `</span>`
-        )
-      }).thenWaitFor(duration * 2).then(() => {
-        expect(vm.$el.innerHTML.replace(/\s?style=""(\s?)/g, '$1')).toBe(
-          `<span>` +
-            `<div class="test">d</div>` +
-            `<div class="test">b</div>` +
-            `<div class="test">a</div>` +
-          `</span>`
-        )
-      }).then(done)
-    })
-
-    it('warn unkeyed children', () => {
-      new Vue({
-        template: `<div><transition-group><div v-for="i in 3"></div></transition-group></div>`
-      }).$mount()
-      expect('<transition-group> children must be keyed: <div>').toHaveBeenWarned()
-    })
-
-    // GitHub issue #6006
-    it('should work with dynamic name', done => {
-      const vm = new Vue({
-        template: `
-          <div>
-            <transition-group :name="name">
-              <div v-for="item in items" :key="item">{{ item }}</div>
-            </transition-group>
-          </div>
-        `,
-        data: {
-          items: ['a', 'b', 'c'],
-          name: 'group'
-        }
-      }).$mount(el)
-
-      vm.name = 'invalid-name'
-      vm.items = ['b', 'c', 'a']
-      waitForUpdate(() => {
-        expect(vm.$el.innerHTML.replace(/\s?style=""(\s?)/g, '$1')).toBe(
-          `<span>` +
-            `<div>b</div>` +
-            `<div>c</div>` +
-            `<div>a</div>` +
-          `</span>`
-        )
-        vm.name = 'group'
-        vm.items = ['a', 'b', 'c']
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML.replace(/\s?style=""(\s?)/g, '$1')).toBe(
-          `<span>` +
-            `<div class="group-move">a</div>` +
-            `<div class="group-move">b</div>` +
-            `<div class="group-move">c</div>` +
-          `</span>`
-        )
-      }).thenWaitFor(duration * 2 + buffer).then(() => {
-        expect(vm.$el.innerHTML.replace(/\s?style=""(\s?)/g, '$1')).toBe(
-          `<span>` +
-            `<div>a</div>` +
-            `<div>b</div>` +
-            `<div>c</div>` +
-          `</span>`
-        )
-      }).then(done)
-    })
-  })
-}
diff --git a/1.Vue/test/unit/features/transition/transition-mode.spec.js b/1.Vue/test/unit/features/transition/transition-mode.spec.js
deleted file mode 100644
index f8afca8..0000000
--- a/1.Vue/test/unit/features/transition/transition-mode.spec.js
+++ /dev/null
@@ -1,569 +0,0 @@
-import Vue from 'vue'
-import injectStyles from './inject-styles'
-import { isIE9 } from 'core/util/env'
-import { nextFrame } from 'web/runtime/transition-util'
-
-if (!isIE9) {
-  describe('Transition mode', () => {
-    const { duration, buffer } = injectStyles()
-    const components = {
-      one: { template: '<div>one</div>' },
-      two: { template: '<div>two</div>' }
-    }
-
-    let el
-    beforeEach(() => {
-      el = document.createElement('div')
-      document.body.appendChild(el)
-    })
-
-    it('dynamic components, simultaneous', done => {
-      const vm = new Vue({
-        template: `<div>
-          <transition>
-            <component :is="view" class="test">
-            </component>
-          </transition>
-        </div>`,
-        data: { view: 'one' },
-        components
-      }).$mount(el)
-      expect(vm.$el.textContent).toBe('one')
-      vm.view = 'two'
-      waitForUpdate(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test v-leave v-leave-active">one</div>' +
-          '<div class="test v-enter v-enter-active">two</div>'
-        )
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test v-leave-active v-leave-to">one</div>' +
-          '<div class="test v-enter-active v-enter-to">two</div>'
-        )
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">two</div>'
-        )
-      }).then(done)
-    })
-
-    it('dynamic components, out-in', done => {
-      let next
-      const vm = new Vue({
-        template: `<div>
-          <transition name="test" mode="out-in" @after-leave="afterLeave">
-            <component :is="view" class="test">
-            </component>
-          </transition>
-        </div>`,
-        data: { view: 'one' },
-        components,
-        methods: {
-          afterLeave () {
-            next()
-          }
-        }
-      }).$mount(el)
-      expect(vm.$el.textContent).toBe('one')
-      vm.view = 'two'
-      waitForUpdate(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-leave test-leave-active">one</div><!---->'
-        )
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-leave-active test-leave-to">one</div><!---->'
-        )
-      }).thenWaitFor(_next => { next = _next }).then(() => {
-        expect(vm.$el.innerHTML).toBe('<!---->')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-enter test-enter-active">two</div>'
-        )
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-enter-active test-enter-to">two</div>'
-        )
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">two</div>'
-        )
-      }).then(done)
-    })
-
-    // #3440
-    it('dynamic components, out-in (with extra re-render)', done => {
-      let next
-      const vm = new Vue({
-        template: `<div>
-          <transition name="test" mode="out-in" @after-leave="afterLeave">
-            <component :is="view" class="test">
-            </component>
-          </transition>
-        </div>`,
-        data: { view: 'one' },
-        components,
-        methods: {
-          afterLeave () {
-            next()
-          }
-        }
-      }).$mount(el)
-      expect(vm.$el.textContent).toBe('one')
-      vm.view = 'two'
-      waitForUpdate(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-leave test-leave-active">one</div><!---->'
-        )
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-leave-active test-leave-to">one</div><!---->'
-        )
-        // Force re-render before the element finishes leaving
-        // this should not cause the incoming element to enter early
-        vm.$forceUpdate()
-      }).thenWaitFor(_next => { next = _next }).then(() => {
-        expect(vm.$el.innerHTML).toBe('<!---->')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-enter test-enter-active">two</div>'
-        )
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-enter-active test-enter-to">two</div>'
-        )
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">two</div>'
-        )
-      }).then(done)
-    })
-
-    it('dynamic components, in-out', done => {
-      let next
-      const vm = new Vue({
-        template: `<div>
-          <transition name="test" mode="in-out" @after-enter="afterEnter">
-            <component :is="view" class="test">
-            </component>
-          </transition>
-        </div>`,
-        data: { view: 'one' },
-        components,
-        methods: {
-          afterEnter () {
-            next()
-          }
-        }
-      }).$mount(el)
-      expect(vm.$el.textContent).toBe('one')
-      vm.view = 'two'
-      waitForUpdate(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">one</div>' +
-          '<div class="test test-enter test-enter-active">two</div>'
-        )
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">one</div>' +
-          '<div class="test test-enter-active test-enter-to">two</div>'
-        )
-      }).thenWaitFor(_next => { next = _next }).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">one</div>' +
-          '<div class="test">two</div>'
-        )
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-leave test-leave-active">one</div>' +
-          '<div class="test">two</div>'
-        )
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-leave-active test-leave-to">one</div>' +
-          '<div class="test">two</div>'
-        )
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">two</div>'
-        )
-      }).then(done)
-    })
-
-    it('dynamic components, in-out with early cancel', done => {
-      let next
-      const vm = new Vue({
-        template: `<div>
-          <transition name="test" mode="in-out" @after-enter="afterEnter">
-            <component :is="view" class="test"></component>
-          </transition>
-        </div>`,
-        data: { view: 'one' },
-        components,
-        methods: {
-          afterEnter () {
-            next()
-          }
-        }
-      }).$mount(el)
-      expect(vm.$el.textContent).toBe('one')
-      vm.view = 'two'
-      waitForUpdate(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">one</div>' +
-          '<div class="test test-enter test-enter-active">two</div>'
-        )
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">one</div>' +
-          '<div class="test test-enter-active test-enter-to">two</div>'
-        )
-        // switch again before enter finishes,
-        // this cancels both enter and leave.
-        vm.view = 'one'
-      }).then(() => {
-        // 1. the pending leaving "one" should be removed instantly.
-        // 2. the entering "two" should be placed into its final state instantly.
-        // 3. a new "one" is created and entering
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">two</div>' +
-          '<div class="test test-enter test-enter-active">one</div>'
-        )
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">two</div>' +
-          '<div class="test test-enter-active test-enter-to">one</div>'
-        )
-      }).thenWaitFor(_next => { next = _next }).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">two</div>' +
-          '<div class="test">one</div>'
-        )
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-leave test-leave-active">two</div>' +
-          '<div class="test">one</div>'
-        )
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-leave-active test-leave-to">two</div>' +
-          '<div class="test">one</div>'
-        )
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">one</div>'
-        )
-      }).then(done).then(done)
-    })
-
-    it('normal elements with different keys, simultaneous', done => {
-      const vm = new Vue({
-        template: `<div>
-          <transition>
-            <div :key="view" class="test">{{view}}</div>
-          </transition>
-        </div>`,
-        data: { view: 'one' },
-        components
-      }).$mount(el)
-      expect(vm.$el.textContent).toBe('one')
-      vm.view = 'two'
-      waitForUpdate(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test v-leave v-leave-active">one</div>' +
-          '<div class="test v-enter v-enter-active">two</div>'
-        )
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test v-leave-active v-leave-to">one</div>' +
-          '<div class="test v-enter-active v-enter-to">two</div>'
-        )
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">two</div>'
-        )
-      }).then(done)
-    })
-
-    it('normal elements with different keys, out-in', done => {
-      let next
-      const vm = new Vue({
-        template: `<div>
-          <transition name="test" mode="out-in" @after-leave="afterLeave">
-            <div :key="view" class="test">{{view}}</div>
-          </transition>
-        </div>`,
-        data: { view: 'one' },
-        components,
-        methods: {
-          afterLeave () {
-            next()
-          }
-        }
-      }).$mount(el)
-      expect(vm.$el.textContent).toBe('one')
-      vm.view = 'two'
-      waitForUpdate(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-leave test-leave-active">one</div><!---->'
-        )
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-leave-active test-leave-to">one</div><!---->'
-        )
-      }).thenWaitFor(_next => { next = _next }).then(() => {
-        expect(vm.$el.innerHTML).toBe('<!---->')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-enter test-enter-active">two</div>'
-        )
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-enter-active test-enter-to">two</div>'
-        )
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">two</div>'
-        )
-      }).then(done)
-    })
-
-    it('normal elements with different keys, in-out', done => {
-      let next
-      const vm = new Vue({
-        template: `<div>
-          <transition name="test" mode="in-out" @after-enter="afterEnter">
-            <div :key="view" class="test">{{view}}</div>
-          </transition>
-        </div>`,
-        data: { view: 'one' },
-        components,
-        methods: {
-          afterEnter () {
-            next()
-          }
-        }
-      }).$mount(el)
-      expect(vm.$el.textContent).toBe('one')
-      vm.view = 'two'
-      waitForUpdate(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">one</div>' +
-          '<div class="test test-enter test-enter-active">two</div>'
-        )
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">one</div>' +
-          '<div class="test test-enter-active test-enter-to">two</div>'
-        )
-      }).thenWaitFor(_next => { next = _next }).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">one</div>' +
-          '<div class="test">two</div>'
-        )
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-leave test-leave-active">one</div>' +
-          '<div class="test">two</div>'
-        )
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-leave-active test-leave-to">one</div>' +
-          '<div class="test">two</div>'
-        )
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">two</div>'
-        )
-      }).then(done)
-    })
-
-    it('transition out-in on async component (resolve before leave complete)', done => {
-      const vm = new Vue({
-        template: `
-          <div>
-            <transition name="test-anim" mode="out-in">
-              <component-a v-if="ok"></component-a>
-              <component-b v-else></component-b>
-            </transition>
-          </div>
-        `,
-        components: {
-          componentA: resolve => {
-            setTimeout(() => {
-              resolve({ template: '<div><h1>component A</h1></div>' })
-              next1()
-            }, duration / 2)
-          },
-          componentB: resolve => {
-            setTimeout(() => {
-              resolve({ template: '<div><h1>component B</h1></div>' })
-            }, duration / 2)
-          }
-        },
-        data: {
-          ok: true
-        }
-      }).$mount(el)
-
-      expect(vm.$el.innerHTML).toBe('<!---->')
-
-      function next1 () {
-        Vue.nextTick(() => {
-          expect(vm.$el.children.length).toBe(1)
-          expect(vm.$el.textContent).toBe('component A')
-          expect(vm.$el.children[0].className).toBe('test-anim-enter test-anim-enter-active')
-          nextFrame(() => {
-            expect(vm.$el.children[0].className).toBe('test-anim-enter-active test-anim-enter-to')
-            setTimeout(() => {
-              expect(vm.$el.children[0].className).toBe('')
-              vm.ok = false
-              next2()
-            }, duration + buffer)
-          })
-        })
-      }
-
-      function next2 () {
-        waitForUpdate(() => {
-          expect(vm.$el.children.length).toBe(1)
-          expect(vm.$el.textContent).toBe('component A')
-          expect(vm.$el.children[0].className).toBe('test-anim-leave test-anim-leave-active')
-        }).thenWaitFor(nextFrame).then(() => {
-          expect(vm.$el.children[0].className).toBe('test-anim-leave-active test-anim-leave-to')
-        }).thenWaitFor(duration + buffer).then(() => {
-          expect(vm.$el.children.length).toBe(1)
-          expect(vm.$el.textContent).toBe('component B')
-          expect(vm.$el.children[0].className).toMatch('test-anim-enter-active')
-        }).thenWaitFor(duration * 2).then(() => {
-          expect(vm.$el.children[0].className).toBe('')
-        }).then(done)
-      }
-    })
-
-    it('transition out-in on async component (resolve after leave complete)', done => {
-      const vm = new Vue({
-        template: `
-          <div>
-            <transition name="test-anim" mode="out-in">
-              <component-a v-if="ok"></component-a>
-              <component-b v-else></component-b>
-            </transition>
-          </div>
-        `,
-        components: {
-          componentA: { template: '<div><h1>component A</h1></div>' },
-          componentB: resolve => {
-            setTimeout(() => {
-              resolve({ template: '<div><h1>component B</h1></div>' })
-              Vue.nextTick(next)
-            }, (duration + buffer) * 1.7)
-          }
-        },
-        data: {
-          ok: true
-        }
-      }).$mount(el)
-
-      expect(vm.$el.innerHTML).toBe('<div><h1>component A</h1></div>')
-
-      let next
-
-      vm.ok = false
-      waitForUpdate(() => {
-        expect(vm.$el.children.length).toBe(1)
-        expect(vm.$el.textContent).toBe('component A')
-        expect(vm.$el.children[0].className).toBe('test-anim-leave test-anim-leave-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test-anim-leave-active test-anim-leave-to')
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.children.length).toBe(0)
-        expect(vm.$el.innerHTML).toBe('<!---->')
-      }).thenWaitFor(_next => { next = _next }).then(() => {
-        expect(vm.$el.children.length).toBe(1)
-        expect(vm.$el.textContent).toBe('component B')
-        expect(vm.$el.children[0].className).toBe('test-anim-enter test-anim-enter-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test-anim-enter-active test-anim-enter-to')
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.children.length).toBe(1)
-        expect(vm.$el.textContent).toBe('component B')
-        expect(vm.$el.children[0].className).toBe('')
-      }).then(done)
-    })
-
-    it('transition in-out on async component', done => {
-      const vm = new Vue({
-        template: `
-          <div>
-            <transition name="test-anim" mode="in-out">
-              <component-a v-if="ok"></component-a>
-              <component-b v-else></component-b>
-            </transition>
-          </div>
-        `,
-        components: {
-          componentA: resolve => {
-            setTimeout(() => {
-              resolve({ template: '<div><h1>component A</h1></div>' })
-              next1()
-            }, duration / 2)
-          },
-          componentB: resolve => {
-            setTimeout(() => {
-              resolve({ template: '<div><h1>component B</h1></div>' })
-              next2()
-            }, duration / 2)
-          }
-        },
-        data: {
-          ok: true
-        }
-      }).$mount(el)
-
-      expect(vm.$el.innerHTML).toBe('<!---->')
-
-      function next1 () {
-        Vue.nextTick(() => {
-          expect(vm.$el.children.length).toBe(1)
-          expect(vm.$el.textContent).toBe('component A')
-          expect(vm.$el.children[0].className).toBe('test-anim-enter test-anim-enter-active')
-          nextFrame(() => {
-            expect(vm.$el.children[0].className).toBe('test-anim-enter-active test-anim-enter-to')
-            setTimeout(() => {
-              expect(vm.$el.children[0].className).toBe('')
-              vm.ok = false
-            }, duration + buffer)
-          })
-        })
-      }
-
-      function next2 () {
-        waitForUpdate(() => {
-          expect(vm.$el.children.length).toBe(2)
-          expect(vm.$el.textContent).toBe('component Acomponent B')
-          expect(vm.$el.children[0].className).toBe('')
-          expect(vm.$el.children[1].className).toBe('test-anim-enter test-anim-enter-active')
-        }).thenWaitFor(nextFrame).then(() => {
-          expect(vm.$el.children[1].className).toBe('test-anim-enter-active test-anim-enter-to')
-        }).thenWaitFor(duration + buffer).then(() => {
-          expect(vm.$el.children.length).toBe(2)
-          expect(vm.$el.textContent).toBe('component Acomponent B')
-          expect(vm.$el.children[0].className).toMatch('test-anim-leave-active')
-          expect(vm.$el.children[1].className).toBe('')
-        }).thenWaitFor(duration + buffer).then(() => {
-          expect(vm.$el.children.length).toBe(1)
-          expect(vm.$el.textContent).toBe('component B')
-          expect(vm.$el.children[0].className).toBe('')
-        }).then(done)
-      }
-    })
-
-    it('warn invalid mode', () => {
-      new Vue({
-        template: '<transition mode="foo"><div>123</div></transition>'
-      }).$mount()
-      expect('invalid <transition> mode: foo').toHaveBeenWarned()
-    })
-  })
-}
diff --git a/1.Vue/test/unit/features/transition/transition.spec.js b/1.Vue/test/unit/features/transition/transition.spec.js
deleted file mode 100644
index 6bfc8e7..0000000
--- a/1.Vue/test/unit/features/transition/transition.spec.js
+++ /dev/null
@@ -1,1305 +0,0 @@
-import Vue from 'vue'
-import injectStyles from './inject-styles'
-import { isIE9 } from 'core/util/env'
-import { nextFrame } from 'web/runtime/transition-util'
-
-if (!isIE9) {
-  describe('Transition basic', () => {
-    const { duration, buffer } = injectStyles()
-    const explicitDuration = duration * 2
-
-    let el
-    beforeEach(() => {
-      el = document.createElement('div')
-      document.body.appendChild(el)
-    })
-
-    it('basic transition', done => {
-      const vm = new Vue({
-        template: '<div><transition><div v-if="ok" class="test">foo</div></transition></div>',
-        data: { ok: true }
-      }).$mount(el)
-
-      // should not apply transition on initial render by default
-      expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
-      vm.ok = false
-      waitForUpdate(() => {
-        expect(vm.$el.children[0].className).toBe('test v-leave v-leave-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test v-leave-active v-leave-to')
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.children.length).toBe(0)
-        vm.ok = true
-      }).then(() => {
-        expect(vm.$el.children[0].className).toBe('test v-enter v-enter-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test v-enter-active v-enter-to')
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.children[0].className).toBe('test')
-      }).then(done)
-    })
-
-    it('named transition', done => {
-      const vm = new Vue({
-        template: '<div><transition name="test"><div v-if="ok" class="test">foo</div></transition></div>',
-        data: { ok: true }
-      }).$mount(el)
-
-      // should not apply transition on initial render by default
-      expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
-      vm.ok = false
-      waitForUpdate(() => {
-        expect(vm.$el.children[0].className).toBe('test test-leave test-leave-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test test-leave-active test-leave-to')
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.children.length).toBe(0)
-        vm.ok = true
-      }).then(() => {
-        expect(vm.$el.children[0].className).toBe('test test-enter test-enter-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test test-enter-active test-enter-to')
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.children[0].className).toBe('test')
-      }).then(done)
-    })
-
-    it('custom transition classes', done => {
-      const vm = new Vue({
-        template: `
-          <div>
-            <transition
-              enter-class="hello"
-              enter-active-class="hello-active"
-              enter-to-class="hello-to"
-              leave-class="bye"
-              leave-to-class="bye-to"
-              leave-active-class="byebye active more ">
-              <div v-if="ok" class="test">foo</div>
-            </transition>
-          </div>
-        `,
-        data: { ok: true }
-      }).$mount(el)
-
-      // should not apply transition on initial render by default
-      expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
-      vm.ok = false
-      waitForUpdate(() => {
-        expect(vm.$el.children[0].className).toBe('test bye byebye active more')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test byebye active more bye-to')
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.children.length).toBe(0)
-        vm.ok = true
-      }).then(() => {
-        expect(vm.$el.children[0].className).toBe('test hello hello-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test hello-active hello-to')
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.children[0].className).toBe('test')
-      }).then(done)
-    })
-
-    it('dynamic transition', done => {
-      const vm = new Vue({
-        template: `
-          <div>
-            <transition :name="trans">
-              <div v-if="ok" class="test">foo</div>
-            </transition>
-          </div>
-        `,
-        data: {
-          ok: true,
-          trans: 'test'
-        }
-      }).$mount(el)
-
-      // should not apply transition on initial render by default
-      expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
-      vm.ok = false
-      waitForUpdate(() => {
-        expect(vm.$el.children[0].className).toBe('test test-leave test-leave-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test test-leave-active test-leave-to')
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.children.length).toBe(0)
-        vm.ok = true
-        vm.trans = 'changed'
-      }).then(() => {
-        expect(vm.$el.children[0].className).toBe('test changed-enter changed-enter-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test changed-enter-active changed-enter-to')
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.children[0].className).toBe('test')
-      }).then(done)
-    })
-
-    it('inline transition object', done => {
-      const enter = jasmine.createSpy('enter')
-      const leave = jasmine.createSpy('leave')
-      const vm = new Vue({
-        render (h) {
-          return h('div', null, [
-            h('transition', {
-              props: {
-                name: 'inline',
-                enterClass: 'hello',
-                enterToClass: 'hello-to',
-                enterActiveClass: 'hello-active',
-                leaveClass: 'bye',
-                leaveToClass: 'bye-to',
-                leaveActiveClass: 'byebye active'
-              },
-              on: {
-                enter,
-                leave
-              }
-            }, this.ok ? [h('div', { class: 'test' }, 'foo')] : undefined)
-          ])
-        },
-        data: { ok: true }
-      }).$mount(el)
-
-      // should not apply transition on initial render by default
-      expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
-      vm.ok = false
-      waitForUpdate(() => {
-        expect(vm.$el.children[0].className).toBe('test bye byebye active')
-        expect(leave).toHaveBeenCalled()
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test byebye active bye-to')
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.children.length).toBe(0)
-        vm.ok = true
-      }).then(() => {
-        expect(vm.$el.children[0].className).toBe('test hello hello-active')
-        expect(enter).toHaveBeenCalled()
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test hello-active hello-to')
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.children[0].className).toBe('test')
-      }).then(done)
-    })
-
-    it('transition events', done => {
-      const onLeaveSpy = jasmine.createSpy('leave')
-      const onEnterSpy = jasmine.createSpy('enter')
-      const beforeLeaveSpy = jasmine.createSpy('beforeLeave')
-      const beforeEnterSpy = jasmine.createSpy('beforeEnter')
-      const afterLeaveSpy = jasmine.createSpy('afterLeave')
-      const afterEnterSpy = jasmine.createSpy('afterEnter')
-
-      const vm = new Vue({
-        template: `
-          <div>
-            <transition
-              name="test"
-              @before-enter="beforeEnter"
-              @enter="enter"
-              @after-enter="afterEnter"
-              @before-leave="beforeLeave"
-              @leave="leave"
-              @after-leave="afterLeave">
-              <div v-if="ok" class="test">foo</div>
-            </transition>
-          </div>
-        `,
-        data: { ok: true },
-        methods: {
-          beforeLeave: (el) => {
-            expect(el).toBe(vm.$el.children[0])
-            expect(el.className).toBe('test')
-            beforeLeaveSpy(el)
-          },
-          leave: (el) => onLeaveSpy(el),
-          afterLeave: (el) => afterLeaveSpy(el),
-          beforeEnter: (el) => {
-            expect(vm.$el.contains(el)).toBe(false)
-            expect(el.className).toBe('test')
-            beforeEnterSpy(el)
-          },
-          enter: (el) => {
-            expect(vm.$el.contains(el)).toBe(true)
-            onEnterSpy(el)
-          },
-          afterEnter: (el) => afterEnterSpy(el)
-        }
-      }).$mount(el)
-
-      // should not apply transition on initial render by default
-      expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
-
-      let _el = vm.$el.children[0]
-      vm.ok = false
-      waitForUpdate(() => {
-        expect(beforeLeaveSpy).toHaveBeenCalledWith(_el)
-        expect(onLeaveSpy).toHaveBeenCalledWith(_el)
-        expect(vm.$el.children[0].className).toBe('test test-leave test-leave-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(afterLeaveSpy).not.toHaveBeenCalled()
-        expect(vm.$el.children[0].className).toBe('test test-leave-active test-leave-to')
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(afterLeaveSpy).toHaveBeenCalledWith(_el)
-        expect(vm.$el.children.length).toBe(0)
-        vm.ok = true
-      }).then(() => {
-        _el = vm.$el.children[0]
-        expect(beforeEnterSpy).toHaveBeenCalledWith(_el)
-        expect(onEnterSpy).toHaveBeenCalledWith(_el)
-        expect(vm.$el.children[0].className).toBe('test test-enter test-enter-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(afterEnterSpy).not.toHaveBeenCalled()
-        expect(vm.$el.children[0].className).toBe('test test-enter-active test-enter-to')
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(afterEnterSpy).toHaveBeenCalledWith(_el)
-        expect(vm.$el.children[0].className).toBe('test')
-      }).then(done)
-    })
-
-    it('transition events (v-show)', done => {
-      const onLeaveSpy = jasmine.createSpy('leave')
-      const onEnterSpy = jasmine.createSpy('enter')
-      const beforeLeaveSpy = jasmine.createSpy('beforeLeave')
-      const beforeEnterSpy = jasmine.createSpy('beforeEnter')
-      const afterLeaveSpy = jasmine.createSpy('afterLeave')
-      const afterEnterSpy = jasmine.createSpy('afterEnter')
-
-      const vm = new Vue({
-        template: `
-          <div>
-            <transition
-              name="test"
-              @before-enter="beforeEnter"
-              @enter="enter"
-              @after-enter="afterEnter"
-              @before-leave="beforeLeave"
-              @leave="leave"
-              @after-leave="afterLeave">
-              <div v-show="ok" class="test">foo</div>
-            </transition>
-          </div>
-        `,
-        data: { ok: true },
-        methods: {
-          beforeLeave: (el) => {
-            expect(el.style.display).toBe('')
-            expect(el).toBe(vm.$el.children[0])
-            expect(el.className).toBe('test')
-            beforeLeaveSpy(el)
-          },
-          leave: (el) => {
-            expect(el.style.display).toBe('')
-            onLeaveSpy(el)
-          },
-          afterLeave: (el) => {
-            expect(el.style.display).toBe('none')
-            afterLeaveSpy(el)
-          },
-          beforeEnter: (el) => {
-            expect(el.className).toBe('test')
-            expect(el.style.display).toBe('none')
-            beforeEnterSpy(el)
-          },
-          enter: (el) => {
-            expect(el.style.display).toBe('')
-            onEnterSpy(el)
-          },
-          afterEnter: (el) => {
-            expect(el.style.display).toBe('')
-            afterEnterSpy(el)
-          }
-        }
-      }).$mount(el)
-
-      // should not apply transition on initial render by default
-      expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
-
-      let _el = vm.$el.children[0]
-      vm.ok = false
-      waitForUpdate(() => {
-        expect(beforeLeaveSpy).toHaveBeenCalledWith(_el)
-        expect(onLeaveSpy).toHaveBeenCalledWith(_el)
-        expect(vm.$el.children[0].className).toBe('test test-leave test-leave-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(afterLeaveSpy).not.toHaveBeenCalled()
-        expect(vm.$el.children[0].className).toBe('test test-leave-active test-leave-to')
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(afterLeaveSpy).toHaveBeenCalledWith(_el)
-        expect(vm.$el.children[0].style.display).toBe('none')
-        vm.ok = true
-      }).then(() => {
-        _el = vm.$el.children[0]
-        expect(beforeEnterSpy).toHaveBeenCalledWith(_el)
-        expect(onEnterSpy).toHaveBeenCalledWith(_el)
-        expect(vm.$el.children[0].className).toBe('test test-enter test-enter-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(afterEnterSpy).not.toHaveBeenCalled()
-        expect(vm.$el.children[0].className).toBe('test test-enter-active test-enter-to')
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(afterEnterSpy).toHaveBeenCalledWith(_el)
-        expect(vm.$el.children[0].className).toBe('test')
-      }).then(done)
-    })
-
-    it('explicit user callback in JavaScript hooks', done => {
-      let next
-      const vm = new Vue({
-        template: `<div>
-          <transition name="test" @enter="enter" @leave="leave">
-            <div v-if="ok" class="test">foo</div>
-          </transition>
-        </div>`,
-        data: { ok: true },
-        methods: {
-          enter: (el, cb) => {
-            next = cb
-          },
-          leave: (el, cb) => {
-            next = cb
-          }
-        }
-      }).$mount(el)
-      vm.ok = false
-      waitForUpdate(() => {
-        expect(vm.$el.children[0].className).toBe('test test-leave test-leave-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test test-leave-active test-leave-to')
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.children[0].className).toBe('test test-leave-active test-leave-to')
-        expect(next).toBeTruthy()
-        next()
-        expect(vm.$el.children.length).toBe(0)
-      }).then(() => {
-        vm.ok = true
-      }).then(() => {
-        expect(vm.$el.children[0].className).toBe('test test-enter test-enter-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test test-enter-active test-enter-to')
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.children[0].className).toBe('test test-enter-active test-enter-to')
-        expect(next).toBeTruthy()
-        next()
-        expect(vm.$el.children[0].className).toBe('test')
-      }).then(done)
-    })
-
-    it('css: false', done => {
-      const enterSpy = jasmine.createSpy('enter')
-      const leaveSpy = jasmine.createSpy('leave')
-      const vm = new Vue({
-        template: `
-          <div>
-            <transition :css="false" name="test" @enter="enter" @leave="leave">
-              <div v-if="ok" class="test">foo</div>
-            </transition>
-          </div>
-        `,
-        data: { ok: true },
-        methods: {
-          enter: enterSpy,
-          leave: leaveSpy
-        }
-      }).$mount(el)
-
-      vm.ok = false
-      waitForUpdate(() => {
-        expect(leaveSpy).toHaveBeenCalled()
-        expect(vm.$el.innerHTML).toBe('<!---->')
-        vm.ok = true
-      }).then(() => {
-        expect(enterSpy).toHaveBeenCalled()
-        expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
-      }).then(done)
-    })
-
-    it('no transition detected', done => {
-      const enterSpy = jasmine.createSpy('enter')
-      const leaveSpy = jasmine.createSpy('leave')
-      const vm = new Vue({
-        template: '<div><transition name="nope" @enter="enter" @leave="leave"><div v-if="ok">foo</div></transition></div>',
-        data: { ok: true },
-        methods: {
-          enter: enterSpy,
-          leave: leaveSpy
-        }
-      }).$mount(el)
-
-      vm.ok = false
-      waitForUpdate(() => {
-        expect(leaveSpy).toHaveBeenCalled()
-        expect(vm.$el.innerHTML).toBe('<div class="nope-leave nope-leave-active">foo</div><!---->')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe('<!---->')
-        vm.ok = true
-      }).then(() => {
-        expect(enterSpy).toHaveBeenCalled()
-        expect(vm.$el.innerHTML).toBe('<div class="nope-enter nope-enter-active">foo</div>')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe('<div>foo</div>')
-      }).then(done)
-    })
-
-    it('enterCancelled', done => {
-      const spy = jasmine.createSpy('enterCancelled')
-      const vm = new Vue({
-        template: `
-          <div>
-            <transition name="test" @enter-cancelled="enterCancelled">
-              <div v-if="ok" class="test">foo</div>
-            </transition>
-          </div>
-        `,
-        data: { ok: false },
-        methods: {
-          enterCancelled: spy
-        }
-      }).$mount(el)
-
-      expect(vm.$el.innerHTML).toBe('<!---->')
-      vm.ok = true
-      waitForUpdate(() => {
-        expect(vm.$el.children[0].className).toBe('test test-enter test-enter-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test test-enter-active test-enter-to')
-      }).thenWaitFor(duration / 2).then(() => {
-        vm.ok = false
-      }).then(() => {
-        expect(spy).toHaveBeenCalled()
-        expect(vm.$el.children[0].className).toBe('test test-leave test-leave-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test test-leave-active test-leave-to')
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.children.length).toBe(0)
-      }).then(done)
-    })
-
-    it('should remove stale leaving elements', done => {
-      const spy = jasmine.createSpy('afterLeave')
-      const vm = new Vue({
-        template: `
-          <div>
-            <transition name="test" @after-leave="afterLeave">
-              <div v-if="ok" class="test">foo</div>
-            </transition>
-          </div>
-        `,
-        data: { ok: true },
-        methods: {
-          afterLeave: spy
-        }
-      }).$mount(el)
-
-      expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
-      vm.ok = false
-      waitForUpdate(() => {
-        expect(vm.$el.children[0].className).toBe('test test-leave test-leave-active')
-      }).thenWaitFor(duration / 2).then(() => {
-        vm.ok = true
-      }).then(() => {
-        expect(spy).toHaveBeenCalled()
-        expect(vm.$el.children.length).toBe(1) // should have removed leaving element
-        expect(vm.$el.children[0].className).toBe('test test-enter test-enter-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test test-enter-active test-enter-to')
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
-      }).then(done)
-    })
-
-    it('transition with v-show', done => {
-      const vm = new Vue({
-        template: `
-          <div>
-            <transition name="test">
-              <div v-show="ok" class="test">foo</div>
-            </transition>
-          </div>
-        `,
-        data: { ok: true }
-      }).$mount(el)
-
-      // should not apply transition on initial render by default
-      expect(vm.$el.textContent).toBe('foo')
-      expect(vm.$el.children[0].style.display).toBe('')
-      expect(vm.$el.children[0].className).toBe('test')
-      vm.ok = false
-      waitForUpdate(() => {
-        expect(vm.$el.children[0].className).toBe('test test-leave test-leave-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test test-leave-active test-leave-to')
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.children[0].style.display).toBe('none')
-        vm.ok = true
-      }).then(() => {
-        expect(vm.$el.children[0].style.display).toBe('')
-        expect(vm.$el.children[0].className).toBe('test test-enter test-enter-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test test-enter-active test-enter-to')
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.children[0].className).toBe('test')
-      }).then(done)
-    })
-
-    it('transition with v-show, inside child component', done => {
-      const vm = new Vue({
-        template: `
-          <div>
-            <test v-show="ok"></test>
-          </div>
-        `,
-        data: { ok: true },
-        components: {
-          test: {
-            template: `<transition name="test"><div class="test">foo</div></transition>`
-          }
-        }
-      }).$mount(el)
-
-      // should not apply transition on initial render by default
-      expect(vm.$el.textContent).toBe('foo')
-      expect(vm.$el.children[0].style.display).toBe('')
-      vm.ok = false
-      waitForUpdate(() => {
-        expect(vm.$el.children[0].className).toBe('test test-leave test-leave-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test test-leave-active test-leave-to')
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.children[0].style.display).toBe('none')
-        vm.ok = true
-      }).then(() => {
-        expect(vm.$el.children[0].style.display).toBe('')
-        expect(vm.$el.children[0].className).toBe('test test-enter test-enter-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test test-enter-active test-enter-to')
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.children[0].className).toBe('test')
-      }).then(done)
-    })
-
-    it('leaveCancelled (v-show only)', done => {
-      const spy = jasmine.createSpy('leaveCancelled')
-      const vm = new Vue({
-        template: `
-          <div>
-            <transition name="test" @leave-cancelled="leaveCancelled">
-              <div v-show="ok" class="test">foo</div>
-            </transition>
-          </div>
-        `,
-        data: { ok: true },
-        methods: {
-          leaveCancelled: spy
-        }
-      }).$mount(el)
-
-      expect(vm.$el.children[0].style.display).toBe('')
-      vm.ok = false
-      waitForUpdate(() => {
-        expect(vm.$el.children[0].className).toBe('test test-leave test-leave-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test test-leave-active test-leave-to')
-      }).thenWaitFor(10).then(() => {
-        vm.ok = true
-      }).then(() => {
-        expect(spy).toHaveBeenCalled()
-        expect(vm.$el.children[0].className).toBe('test test-enter test-enter-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test test-enter-active test-enter-to')
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.children[0].style.display).toBe('')
-      }).then(done)
-    })
-
-    it('leave transition with v-show: cancelled on next frame', done => {
-      const vm = new Vue({
-        template: `
-          <div>
-            <transition name="test">
-              <div v-show="ok" class="test">foo</div>
-            </transition>
-          </div>
-        `,
-        data: { ok: true }
-      }).$mount(el)
-
-      vm.ok = false
-      waitForUpdate(() => {
-        vm.ok = true
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test test-enter-active test-enter-to')
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.children[0].className).toBe('test')
-      }).then(done)
-    })
-
-    it('enter transition with v-show: cancelled on next frame', done => {
-      const vm = new Vue({
-        template: `
-          <div>
-            <transition name="test">
-              <div v-show="ok" class="test">foo</div>
-            </transition>
-          </div>
-        `,
-        data: { ok: false }
-      }).$mount(el)
-
-      vm.ok = true
-      waitForUpdate(() => {
-        vm.ok = false
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test test-leave-active test-leave-to')
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.children[0].className).toBe('test')
-      }).then(done)
-    })
-
-    it('animations', done => {
-      const vm = new Vue({
-        template: `
-          <div>
-            <transition name="test-anim">
-              <div v-if="ok">foo</div>
-            </transition>
-          </div>
-        `,
-        data: { ok: true }
-      }).$mount(el)
-
-      // should not apply transition on initial render by default
-      expect(vm.$el.innerHTML).toBe('<div>foo</div>')
-      vm.ok = false
-      waitForUpdate(() => {
-        expect(vm.$el.children[0].className).toBe('test-anim-leave test-anim-leave-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test-anim-leave-active test-anim-leave-to')
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.children.length).toBe(0)
-        vm.ok = true
-      }).then(() => {
-        expect(vm.$el.children[0].className).toBe('test-anim-enter test-anim-enter-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test-anim-enter-active test-anim-enter-to')
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.children[0].className).toBe('')
-      }).then(done)
-    })
-
-    it('explicit transition type', done => {
-      const vm = new Vue({
-        template: `
-          <div>
-            <transition name="test-anim-long" type="animation">
-              <div v-if="ok" class="test">foo</div>
-            </transition>
-          </div>
-        `,
-        data: { ok: true }
-      }).$mount(el)
-
-      // should not apply transition on initial render by default
-      expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
-      vm.ok = false
-      waitForUpdate(() => {
-        expect(vm.$el.children[0].className).toBe('test test-anim-long-leave test-anim-long-leave-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test test-anim-long-leave-active test-anim-long-leave-to')
-      }).thenWaitFor(duration + 5).then(() => {
-        // should not end early due to transition presence
-        expect(vm.$el.children[0].className).toBe('test test-anim-long-leave-active test-anim-long-leave-to')
-      }).thenWaitFor(duration + 5).then(() => {
-        expect(vm.$el.children.length).toBe(0)
-        vm.ok = true
-      }).then(() => {
-        expect(vm.$el.children[0].className).toBe('test test-anim-long-enter test-anim-long-enter-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test test-anim-long-enter-active test-anim-long-enter-to')
-      }).thenWaitFor(duration + 5).then(() => {
-        expect(vm.$el.children[0].className).toBe('test test-anim-long-enter-active test-anim-long-enter-to')
-      }).thenWaitFor(duration + 5).then(() => {
-        expect(vm.$el.children[0].className).toBe('test')
-      }).then(done)
-    })
-
-    it('transition on appear', done => {
-      const vm = new Vue({
-        template: `
-          <div>
-            <transition name="test"
-              appear
-              appear-class="test-appear"
-              appear-to-class="test-appear-to"
-              appear-active-class="test-appear-active">
-              <div v-if="ok" class="test">foo</div>
-            </transition>
-          </div>
-        `,
-        data: { ok: true }
-      }).$mount(el)
-
-      waitForUpdate(() => {
-        expect(vm.$el.children[0].className).toBe('test test-appear test-appear-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test test-appear-active test-appear-to')
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.children[0].className).toBe('test')
-      }).then(done)
-    })
-
-    it('transition on appear with v-show', done => {
-      const vm = new Vue({
-        template: `
-          <div>
-            <transition name="test" appear>
-              <div v-show="ok" class="test">foo</div>
-            </transition>
-          </div>
-        `,
-        data: { ok: true }
-      }).$mount(el)
-
-      waitForUpdate(() => {
-        expect(vm.$el.children[0].className).toBe('test test-enter test-enter-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test test-enter-active test-enter-to')
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.children[0].className).toBe('test')
-      }).then(done)
-    })
-
-    it('transition on SVG elements', done => {
-      const vm = new Vue({
-        template: `
-          <svg>
-            <transition>
-              <circle cx="0" cy="0" r="10" v-if="ok" class="test"></circle>
-            </transition>
-          </svg>
-        `,
-        data: { ok: true }
-      }).$mount(el)
-
-      // should not apply transition on initial render by default
-      expect(vm.$el.childNodes[0].getAttribute('class')).toBe('test')
-      vm.ok = false
-      waitForUpdate(() => {
-        expect(vm.$el.childNodes[0].getAttribute('class')).toBe('test v-leave v-leave-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.childNodes[0].getAttribute('class')).toBe('test v-leave-active v-leave-to')
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.childNodes.length).toBe(1)
-        expect(vm.$el.childNodes[0].nodeType).toBe(8) // should be an empty comment node
-        expect(vm.$el.childNodes[0].textContent).toBe('')
-        vm.ok = true
-      }).then(() => {
-        expect(vm.$el.childNodes[0].getAttribute('class')).toBe('test v-enter v-enter-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.childNodes[0].getAttribute('class')).toBe('test v-enter-active v-enter-to')
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.childNodes[0].getAttribute('class')).toBe('test')
-      }).then(done)
-    })
-
-    it('transition on child components', done => {
-      const vm = new Vue({
-        template: `
-          <div>
-            <transition>
-              <test v-if="ok" class="test"></test>
-            </transition>
-          </div>
-        `,
-        data: { ok: true },
-        components: {
-          test: {
-            template: `
-              <transition name="test">
-                <div>foo</div>
-              </transition>
-            ` // test transition override from parent
-          }
-        }
-      }).$mount(el)
-
-      // should not apply transition on initial render by default
-      expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
-      vm.ok = false
-      waitForUpdate(() => {
-        expect(vm.$el.children[0].className).toBe('test v-leave v-leave-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test v-leave-active v-leave-to')
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.children.length).toBe(0)
-        vm.ok = true
-      }).then(() => {
-        expect(vm.$el.children[0].className).toBe('test v-enter v-enter-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test v-enter-active v-enter-to')
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.children[0].className).toBe('test')
-      }).then(done)
-    })
-
-    it('transition inside child component with v-if', done => {
-      const vm = new Vue({
-        template: `
-          <div>
-            <test v-if="ok" class="test"></test>
-          </div>
-        `,
-        data: { ok: true },
-        components: {
-          test: {
-            template: `
-              <transition>
-                <div>foo</div>
-              </transition>
-            `
-          }
-        }
-      }).$mount(el)
-
-      // should not apply transition on initial render by default
-      expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
-      vm.ok = false
-      waitForUpdate(() => {
-        expect(vm.$el.children[0].className).toBe('test v-leave v-leave-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test v-leave-active v-leave-to')
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.children.length).toBe(0)
-        vm.ok = true
-      }).then(() => {
-        expect(vm.$el.children[0].className).toBe('test')
-      }).then(done)
-    })
-
-    it('transition with appear inside child component with v-if', done => {
-      const vm = new Vue({
-        template: `
-          <div>
-            <test v-if="ok" class="test"></test>
-          </div>
-        `,
-        data: { ok: true },
-        components: {
-          test: {
-            template: `
-              <transition appear
-                appear-class="test-appear"
-                appear-to-class="test-appear-to"
-                appear-active-class="test-appear-active">
-                <div>foo</div>
-              </transition>
-            `
-          }
-        }
-      }).$mount(el)
-
-      waitForUpdate(() => {
-        expect(vm.$el.children[0].className).toBe('test test-appear test-appear-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test test-appear-active test-appear-to')
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.children[0].className).toBe('test')
-        vm.ok = false
-      }).then(() => {
-        expect(vm.$el.children[0].className).toBe('test v-leave v-leave-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test v-leave-active v-leave-to')
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.children.length).toBe(0)
-      }).then(done)
-    })
-
-    it('transition inside nested child component with v-if', done => {
-      const vm = new Vue({
-        template: `
-          <div>
-            <foo v-if="ok" class="test"></foo>
-          </div>
-        `,
-        data: { ok: true },
-        components: {
-          foo: {
-            template: '<bar></bar>',
-            components: {
-              bar: {
-                template: '<transition><div>foo</div></transition>'
-              }
-            }
-          }
-        }
-      }).$mount(el)
-
-      // should not apply transition on initial render by default
-      expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
-      vm.ok = false
-      waitForUpdate(() => {
-        expect(vm.$el.children[0].className).toBe('test v-leave v-leave-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test v-leave-active v-leave-to')
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.children.length).toBe(0)
-        vm.ok = true
-      }).then(() => {
-        expect(vm.$el.children[0].className).toBe('test')
-      }).then(done)
-    })
-
-    it('transition with appear inside nested child component with v-if', done => {
-      const vm = new Vue({
-        template: `
-          <div>
-            <foo v-if="ok" class="test"></foo>
-          </div>
-        `,
-        data: { ok: true },
-        components: {
-          foo: {
-            template: '<bar></bar>',
-            components: {
-              bar: {
-                template: `
-                  <transition appear
-                    appear-class="test-appear"
-                    appear-to-class="test-appear-to"
-                    appear-active-class="test-appear-active">
-                    <div>foo</div>
-                  </transition>
-                `
-              }
-            }
-          }
-        }
-      }).$mount(el)
-
-      waitForUpdate(() => {
-        expect(vm.$el.children[0].className).toBe('test test-appear test-appear-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test test-appear-active test-appear-to')
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.children[0].className).toBe('test')
-        vm.ok = false
-      }).then(() => {
-        expect(vm.$el.children[0].className).toBe('test v-leave v-leave-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test v-leave-active v-leave-to')
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.children.length).toBe(0)
-      }).then(done)
-    })
-
-    it('custom transition higher-order component', done => {
-      const vm = new Vue({
-        template: '<div><my-transition><div v-if="ok" class="test">foo</div></my-transition></div>',
-        data: { ok: true },
-        components: {
-          'my-transition': {
-            functional: true,
-            render (h, { data, children }) {
-              (data.props || (data.props = {})).name = 'test'
-              return h('transition', data, children)
-            }
-          }
-        }
-      }).$mount(el)
-
-      // should not apply transition on initial render by default
-      expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
-      vm.ok = false
-      waitForUpdate(() => {
-        expect(vm.$el.children[0].className).toBe('test test-leave test-leave-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test test-leave-active test-leave-to')
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.children.length).toBe(0)
-        vm.ok = true
-      }).then(() => {
-        expect(vm.$el.children[0].className).toBe('test test-enter test-enter-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test test-enter-active test-enter-to')
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.children[0].className).toBe('test')
-      }).then(done)
-    })
-
-    it('warn when used on multiple elements', () => {
-      new Vue({
-        template: `<transition><p>1</p><p>2</p></transition>`
-      }).$mount()
-      expect(`<transition> can only be used on a single element`).toHaveBeenWarned()
-    })
-
-    describe('explicit durations -', () => {
-      it('single value', done => {
-        const vm = new Vue({
-          template: `
-            <div>
-              <transition duration="${explicitDuration}">
-                <div v-if="ok" class="test">foo</div>
-              </transition>
-            </div>
-          `,
-          data: { ok: true }
-        }).$mount(el)
-
-        vm.ok = false
-
-        waitForUpdate(() => {
-          expect(vm.$el.children[0].className).toBe('test v-leave v-leave-active')
-        }).thenWaitFor(nextFrame).then(() => {
-          expect(vm.$el.children[0].className).toBe('test v-leave-active v-leave-to')
-        }).thenWaitFor(explicitDuration + buffer).then(() => {
-          expect(vm.$el.children.length).toBe(0)
-          vm.ok = true
-        }).then(() => {
-          expect(vm.$el.children[0].className).toBe('test v-enter v-enter-active')
-        }).thenWaitFor(nextFrame).then(() => {
-          expect(vm.$el.children[0].className).toBe('test v-enter-active v-enter-to')
-        }).thenWaitFor(explicitDuration + buffer).then(() => {
-          expect(vm.$el.children[0].className).toBe('test')
-        }).then(done)
-      })
-
-      it('enter and auto leave', done => {
-        const vm = new Vue({
-          template: `
-            <div>
-              <transition :duration="{ enter: ${explicitDuration} }">
-                <div v-if="ok" class="test">foo</div>
-              </transition>
-            </div>
-          `,
-          data: { ok: true }
-        }).$mount(el)
-
-        vm.ok = false
-
-        waitForUpdate(() => {
-          expect(vm.$el.children[0].className).toBe('test v-leave v-leave-active')
-        }).thenWaitFor(nextFrame).then(() => {
-          expect(vm.$el.children[0].className).toBe('test v-leave-active v-leave-to')
-        }).thenWaitFor(duration + buffer).then(() => {
-          expect(vm.$el.children.length).toBe(0)
-          vm.ok = true
-        }).then(() => {
-          expect(vm.$el.children[0].className).toBe('test v-enter v-enter-active')
-        }).thenWaitFor(nextFrame).then(() => {
-          expect(vm.$el.children[0].className).toBe('test v-enter-active v-enter-to')
-        }).thenWaitFor(explicitDuration + buffer).then(() => {
-          expect(vm.$el.children[0].className).toBe('test')
-        }).then(done)
-      })
-
-      it('leave and auto enter', done => {
-        const vm = new Vue({
-          template: `
-            <div>
-              <transition :duration="{ leave: ${explicitDuration} }">
-                <div v-if="ok" class="test">foo</div>
-              </transition>
-            </div>
-          `,
-          data: { ok: true }
-        }).$mount(el)
-
-        vm.ok = false
-
-        waitForUpdate(() => {
-          expect(vm.$el.children[0].className).toBe('test v-leave v-leave-active')
-        }).thenWaitFor(nextFrame).then(() => {
-          expect(vm.$el.children[0].className).toBe('test v-leave-active v-leave-to')
-        }).thenWaitFor(explicitDuration + buffer).then(() => {
-          expect(vm.$el.children.length).toBe(0)
-          vm.ok = true
-        }).then(() => {
-          expect(vm.$el.children[0].className).toBe('test v-enter v-enter-active')
-        }).thenWaitFor(nextFrame).then(() => {
-          expect(vm.$el.children[0].className).toBe('test v-enter-active v-enter-to')
-        }).thenWaitFor(duration + buffer).then(() => {
-          expect(vm.$el.children[0].className).toBe('test')
-        }).then(done)
-      })
-
-      it('separate enter and leave', done => {
-        const enter = explicitDuration
-        const leave = explicitDuration * 2
-
-        const vm = new Vue({
-          template: `
-            <div>
-              <transition :duration="{ enter: ${enter}, leave: ${leave} }">
-                <div v-if="ok" class="test">foo</div>
-              </transition>
-            </div>
-          `,
-          data: { ok: true }
-        }).$mount(el)
-
-        vm.ok = false
-
-        waitForUpdate(() => {
-          expect(vm.$el.children[0].className).toBe('test v-leave v-leave-active')
-        }).thenWaitFor(nextFrame).then(() => {
-          expect(vm.$el.children[0].className).toBe('test v-leave-active v-leave-to')
-        }).thenWaitFor(leave + buffer).then(() => {
-          expect(vm.$el.children.length).toBe(0)
-          vm.ok = true
-        }).then(() => {
-          expect(vm.$el.children[0].className).toBe('test v-enter v-enter-active')
-        }).thenWaitFor(nextFrame).then(() => {
-          expect(vm.$el.children[0].className).toBe('test v-enter-active v-enter-to')
-        }).thenWaitFor(enter + buffer).then(() => {
-          expect(vm.$el.children[0].className).toBe('test')
-        }).then(done)
-      })
-
-      it('enter and leave + duration change', done => {
-        const enter1 = explicitDuration * 2
-        const enter2 = explicitDuration
-        const leave1 = explicitDuration * 0.5
-        const leave2 = explicitDuration * 3
-
-        const vm = new Vue({
-          template: `
-            <div>
-              <transition :duration="{ enter: enter, leave: leave }">
-                <div v-if="ok" class="test">foo</div>
-              </transition>
-            </div>
-          `,
-          data: {
-            ok: true,
-            enter: enter1,
-            leave: leave1
-          }
-        }).$mount(el)
-
-        vm.ok = false
-
-        waitForUpdate(() => {
-          expect(vm.$el.children[0].className).toBe('test v-leave v-leave-active')
-        }).thenWaitFor(nextFrame).then(() => {
-          expect(vm.$el.children[0].className).toBe('test v-leave-active v-leave-to')
-        }).thenWaitFor(leave1 + buffer).then(() => {
-          expect(vm.$el.children.length).toBe(0)
-          vm.ok = true
-        }).then(() => {
-          expect(vm.$el.children[0].className).toBe('test v-enter v-enter-active')
-        }).thenWaitFor(nextFrame).then(() => {
-          expect(vm.$el.children[0].className).toBe('test v-enter-active v-enter-to')
-        }).thenWaitFor(enter1 + buffer).then(() => {
-          expect(vm.$el.children[0].className).toBe('test')
-          vm.enter = enter2
-          vm.leave = leave2
-        }).then(() => {
-          vm.ok = false
-        }).then(() => {
-          expect(vm.$el.children[0].className).toBe('test v-leave v-leave-active')
-        }).thenWaitFor(nextFrame).then(() => {
-          expect(vm.$el.children[0].className).toBe('test v-leave-active v-leave-to')
-        }).thenWaitFor(leave2 + buffer).then(() => {
-          expect(vm.$el.children.length).toBe(0)
-          vm.ok = true
-        }).then(() => {
-          expect(vm.$el.children[0].className).toBe('test v-enter v-enter-active')
-        }).thenWaitFor(nextFrame).then(() => {
-          expect(vm.$el.children[0].className).toBe('test v-enter-active v-enter-to')
-        }).thenWaitFor(enter2 + buffer).then(() => {
-          expect(vm.$el.children[0].className).toBe('test')
-        }).then(done)
-      }, 10000)
-
-      it('warn invalid durations', done => {
-        const vm = new Vue({
-          template: `
-            <div>
-              <transition :duration="{ enter: NaN, leave: 'foo' }">
-                <div v-if="ok" class="test">foo</div>
-              </transition>
-            </div>
-          `,
-          data: {
-            ok: true
-          }
-        }).$mount(el)
-
-        vm.ok = false
-        waitForUpdate(() => {
-          expect(`<transition> explicit leave duration is not a valid number - got "foo"`).toHaveBeenWarned()
-        }).thenWaitFor(duration + buffer).then(() => {
-          vm.ok = true
-        }).then(() => {
-          expect(`<transition> explicit enter duration is NaN`).toHaveBeenWarned()
-        }).then(done)
-      })
-    })
-
-    // #6687
-    it('transition on child components with empty root node', done => {
-      const vm = new Vue({
-        template: `
-          <div>
-            <transition mode="out-in">
-              <component class="test" :is="view"></component>
-            </transition>
-          </div>
-        `,
-        data: { view: 'one' },
-        components: {
-          'one': {
-            template: '<div v-if="false">one</div>'
-          },
-          'two': {
-            template: '<div>two</div>'
-          }
-        }
-      }).$mount(el)
-
-      // should not apply transition on initial render by default
-      expect(vm.$el.innerHTML).toBe('<!---->')
-      vm.view = 'two'
-      waitForUpdate(() => {
-        expect(vm.$el.innerHTML).toBe('<div class="test v-enter v-enter-active">two</div>')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test v-enter-active v-enter-to')
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.children[0].className).toBe('test')
-        vm.view = 'one'
-      }).then(() => {
-        // incoming comment node is appended instantly because it doesn't have
-        // data and therefore doesn't go through the transition module.
-        expect(vm.$el.innerHTML).toBe('<div class="test v-leave v-leave-active">two</div><!---->')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test v-leave-active v-leave-to')
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.innerHTML).toBe('<!---->')
-      }).then(done)
-    })
-
-    // #8199
-    it('should not throw error when replaced by v-html contents', (done) => {
-      const vm = new Vue({
-        template: `
-          <div>
-            <div v-if="ok" :class="ok">
-              <transition>
-                <span>a</span>
-              </transition>
-            </div>
-            <div v-else v-html="ok"></div>
-          </div>
-        `,
-        data: { ok: true }
-      }).$mount(el)
-
-      vm.ok = false
-      waitForUpdate(() => {
-        expect(vm.$el.children[0].innerHTML).toBe('false')
-      }).then(done)
-    })
-  })
-}
diff --git a/1.Vue/test/unit/index.js b/1.Vue/test/unit/index.js
deleted file mode 100644
index 35df6c9..0000000
--- a/1.Vue/test/unit/index.js
+++ /dev/null
@@ -1,9 +0,0 @@
-require('es6-promise/auto')
-
-// import all helpers
-const helpersContext = require.context('../helpers', true)
-helpersContext.keys().forEach(helpersContext)
-
-// require all test files
-const testsContext = require.context('./', true, /\.spec$/)
-testsContext.keys().forEach(testsContext)
diff --git a/1.Vue/test/unit/karma.base.config.js b/1.Vue/test/unit/karma.base.config.js
deleted file mode 100644
index 700ad6c..0000000
--- a/1.Vue/test/unit/karma.base.config.js
+++ /dev/null
@@ -1,51 +0,0 @@
-const alias = require('../../scripts/alias')
-const featureFlags = require('../../scripts/feature-flags')
-const webpack = require('webpack')
-
-const webpackConfig = {
-  mode: 'development',
-  resolve: {
-    alias: alias
-  },
-  module: {
-    rules: [
-      {
-        test: /\.js$/,
-        loader: 'babel-loader',
-        exclude: /node_modules/
-      }
-    ]
-  },
-  plugins: [
-    new webpack.DefinePlugin({
-      __WEEX__: false,
-      'process.env': {
-        TRANSITION_DURATION: process.env.CI ? 100 : 50,
-        TRANSITION_BUFFER: 10,
-        ...featureFlags
-      }
-    })
-  ],
-  devtool: '#inline-source-map'
-}
-
-// shared config for all unit tests
-module.exports = {
-  frameworks: ['jasmine'],
-  files: [
-    './index.js'
-  ],
-  preprocessors: {
-    './index.js': ['webpack', 'sourcemap']
-  },
-  webpack: webpackConfig,
-  webpackMiddleware: {
-    noInfo: true
-  },
-  plugins: [
-    'karma-jasmine',
-    'karma-mocha-reporter',
-    'karma-sourcemap-loader',
-    'karma-webpack'
-  ]
-}
diff --git a/1.Vue/test/unit/karma.cover.config.js b/1.Vue/test/unit/karma.cover.config.js
deleted file mode 100644
index 639cec4..0000000
--- a/1.Vue/test/unit/karma.cover.config.js
+++ /dev/null
@@ -1,42 +0,0 @@
-const base = require('./karma.base.config.js')
-
-process.env.CHROME_BIN = require('puppeteer').executablePath()
-
-module.exports = function (config) {
-  const options = Object.assign(base, {
-    browsers: ['ChromeHeadlessCI'],
-    customLaunchers: {
-      'ChromeHeadlessCI': {
-        base: 'ChromeHeadless',
-        flags: ['--no-sandbox']
-      }
-    },
-    reporters: ['mocha', 'coverage'],
-    coverageReporter: {
-      reporters: [
-        { type: 'lcov', dir: '../../coverage', subdir: '.' },
-        { type: 'text-summary', dir: '../../coverage', subdir: '.' }
-      ]
-    },
-    singleRun: true,
-    plugins: base.plugins.concat([
-      'karma-coverage',
-      'karma-chrome-launcher'
-    ])
-  })
-
-  // add babel-plugin-istanbul for code instrumentation
-  options.webpack.module.rules[0].options = {
-    plugins: [['istanbul', {
-      exclude: [
-        'test/',
-        'src/compiler/parser/html-parser.js',
-        'src/core/instance/proxy.js',
-        'src/sfc/deindent.js',
-        'src/platforms/weex/'
-      ]
-    }]]
-  }
-
-  config.set(options)
-}
diff --git a/1.Vue/test/unit/karma.dev.config.js b/1.Vue/test/unit/karma.dev.config.js
deleted file mode 100644
index b9b01b2..0000000
--- a/1.Vue/test/unit/karma.dev.config.js
+++ /dev/null
@@ -1,13 +0,0 @@
-const base = require('./karma.base.config.js')
-
-process.env.CHROME_BIN = require('puppeteer').executablePath()
-
-module.exports = function (config) {
-  config.set(Object.assign(base, {
-    browsers: ['ChromeHeadless'],
-    reporters: ['progress'],
-    plugins: base.plugins.concat([
-      'karma-chrome-launcher'
-    ])
-  }))
-}
diff --git a/1.Vue/test/unit/karma.sauce.config.js b/1.Vue/test/unit/karma.sauce.config.js
deleted file mode 100644
index 0c4ab22..0000000
--- a/1.Vue/test/unit/karma.sauce.config.js
+++ /dev/null
@@ -1,106 +0,0 @@
-const webpack = require('webpack')
-const base = require('./karma.base.config.js')
-
-base.webpack.plugins = [
-  new webpack.DefinePlugin({
-    __WEEX__: false,
-    'process.env': {
-      NODE_ENV: '"development"',
-      // sauce lab vms are slow!
-      TRANSITION_DURATION: 500,
-      TRANSITION_BUFFER: 50
-    }
-  })
-]
-
-/**
- * Having too many tests running concurrently on saucelabs
- * causes timeouts and errors, so we have to run them in
- * smaller batches.
- */
-
-const batches = [
-  // the cool kids
-  {
-    sl_chrome: {
-      base: 'SauceLabs',
-      browserName: 'chrome',
-      platform: 'Windows 7'
-    },
-    sl_firefox: {
-      base: 'SauceLabs',
-      browserName: 'firefox'
-    },
-    sl_mac_safari: {
-      base: 'SauceLabs',
-      browserName: 'safari',
-      platform: 'OS X 10.10'
-    }
-  },
-  // ie family
-  {
-    sl_ie_9: {
-      base: 'SauceLabs',
-      browserName: 'internet explorer',
-      platform: 'Windows 7',
-      version: '9'
-    },
-    sl_ie_10: {
-      base: 'SauceLabs',
-      browserName: 'internet explorer',
-      platform: 'Windows 8',
-      version: '10'
-    },
-    sl_ie_11: {
-      base: 'SauceLabs',
-      browserName: 'internet explorer',
-      platform: 'Windows 8.1',
-      version: '11'
-    },
-    sl_edge: {
-      base: 'SauceLabs',
-      browserName: 'MicrosoftEdge',
-      platform: 'Windows 10'
-    }
-  },
-  // mobile
-  {
-    sl_ios_safari_9: {
-      base: 'SauceLabs',
-      browserName: 'iphone',
-      version: '10.3'
-    },
-    sl_android_6_0: {
-      base: 'SauceLabs',
-      browserName: 'android',
-      version: '6.0'
-    }
-  }
-]
-
-module.exports = function (config) {
-  const batch = batches[process.argv[4] || 0]
-
-  config.set(Object.assign(base, {
-    singleRun: true,
-    browsers: Object.keys(batch),
-    customLaunchers: batch,
-    reporters: process.env.CI
-      ? ['dots', 'saucelabs'] // avoid spamming CI output
-      : ['progress', 'saucelabs'],
-    sauceLabs: {
-      testName: 'Vue.js unit tests',
-      recordScreenshots: false,
-      connectOptions: {
-        'no-ssl-bump-domains': 'all' // Ignore SSL error on Android emulator
-      },
-      build: process.env.CIRCLE_BUILD_NUM || process.env.SAUCE_BUILD_ID || Date.now()
-    },
-    // mobile emulators are really slow
-    captureTimeout: 300000,
-    browserNoActivityTimeout: 300000,
-    plugins: base.plugins.concat([
-      'karma-sauce-launcher'
-    ])
-  }))
-}
diff --git a/1.Vue/test/unit/karma.unit.config.js b/1.Vue/test/unit/karma.unit.config.js
deleted file mode 100644
index a933706..0000000
--- a/1.Vue/test/unit/karma.unit.config.js
+++ /dev/null
@@ -1,14 +0,0 @@
-const base = require('./karma.base.config.js')
-
-module.exports = function (config) {
-  config.set(Object.assign(base, {
-    browsers: ['Chrome', 'Firefox', 'Safari'],
-    reporters: ['progress'],
-    singleRun: true,
-    plugins: base.plugins.concat([
-      'karma-chrome-launcher',
-      'karma-firefox-launcher',
-      'karma-safari-launcher'
-    ])
-  }))
-}
diff --git a/1.Vue/test/unit/modules/compiler/codeframe.spec.js b/1.Vue/test/unit/modules/compiler/codeframe.spec.js
deleted file mode 100644
index 318bcdc..0000000
--- a/1.Vue/test/unit/modules/compiler/codeframe.spec.js
+++ /dev/null
@@ -1,74 +0,0 @@
-import { generateCodeFrame } from 'compiler/codeframe'
-
-describe('codeframe', () => {
-  const source = `
-<div>
-  <template key="one"></template>
-  <ul>
-    <li v-for="foobar">hi</li>
-  </ul>
-  <template key="two"></template>
-</div>
-    `.trim()
-
-  it('line near top', () => {
-    const keyStart = source.indexOf(`key="one"`)
-    const keyEnd = keyStart + `key="one"`.length
-    expect(generateCodeFrame(source, keyStart, keyEnd)).toBe(`
-1  |  <div>
-2  |    <template key="one"></template>
-   |              ^^^^^^^^^
-3  |    <ul>
-4  |      <li v-for="foobar">hi</li>
-    `.trim())
-  })
-
-  it('line in middle', () => {
-    // should cover 5 lines
-    const forStart = source.indexOf(`v-for=`)
-    const forEnd = forStart + `v-for="foobar"`.length
-    expect(generateCodeFrame(source, forStart, forEnd)).toBe(`
-2  |    <template key="one"></template>
-3  |    <ul>
-4  |      <li v-for="foobar">hi</li>
-   |          ^^^^^^^^^^^^^^
-5  |    </ul>
-6  |    <template key="two"></template>
-    `.trim())
-  })
-
-  it('line near bottom', () => {
-    const keyStart = source.indexOf(`key="two"`)
-    const keyEnd = keyStart + `key="two"`.length
-    expect(generateCodeFrame(source, keyStart, keyEnd)).toBe(`
-4  |      <li v-for="foobar">hi</li>
-5  |    </ul>
-6  |    <template key="two"></template>
-   |              ^^^^^^^^^
-7  |  </div>
-    `.trim())
-  })
-
-  it('multi-line highlights', () => {
-    const source = `
-<div attr="some
-  multiline
-attr
-">
-</div>
-    `.trim()
-
-    const attrStart = source.indexOf(`attr=`)
-    const attrEnd = source.indexOf(`">`) + 1
-    expect(generateCodeFrame(source, attrStart, attrEnd)).toBe(`
-1  |  <div attr="some
-   |       ^^^^^^^^^^
-2  |    multiline
-   |  ^^^^^^^^^^^
-3  |  attr
-   |  ^^^^
-4  |  ">
-   |  ^
-    `.trim())
-  })
-})
diff --git a/1.Vue/test/unit/modules/compiler/codegen.spec.js b/1.Vue/test/unit/modules/compiler/codegen.spec.js
deleted file mode 100644
index e946e21..0000000
--- a/1.Vue/test/unit/modules/compiler/codegen.spec.js
+++ /dev/null
@@ -1,700 +0,0 @@
-import { parse } from 'compiler/parser/index'
-import { optimize } from 'compiler/optimizer'
-import { generate } from 'compiler/codegen'
-import { isObject, extend } from 'shared/util'
-import { isReservedTag } from 'web/util/index'
-import { baseOptions } from 'web/compiler/options'
-
-function assertCodegen (template, generatedCode, ...args) {
-  let staticRenderFnCodes = []
-  let generateOptions = baseOptions
-  let proc = null
-  let len = args.length
-  while (len--) {
-    const arg = args[len]
-    if (Array.isArray(arg)) {
-      staticRenderFnCodes = arg
-    } else if (isObject(arg)) {
-      generateOptions = arg
-    } else if (typeof arg === 'function') {
-      proc = arg
-    }
-  }
-  const ast = parse(template, baseOptions)
-  optimize(ast, baseOptions)
-  proc && proc(ast)
-  const res = generate(ast, generateOptions)
-  expect(res.render).toBe(generatedCode)
-  expect(res.staticRenderFns).toEqual(staticRenderFnCodes)
-}
-
-/* eslint-disable quotes */
-describe('codegen', () => {
-  it('generate directive', () => {
-    assertCodegen(
-      '<p v-custom1:arg1.modifier="value1" v-custom2></p>',
-      `with(this){return _c('p',{directives:[{name:"custom1",rawName:"v-custom1:arg1.modifier",value:(value1),expression:"value1",arg:"arg1",modifiers:{"modifier":true}},{name:"custom2",rawName:"v-custom2"}]})}`
-    )
-  })
-
-  it('generate filters', () => {
-    assertCodegen(
-      '<div :id="a | b | c">{{ d | e | f }}</div>',
-      `with(this){return _c('div',{attrs:{"id":_f("c")(_f("b")(a))}},[_v(_s(_f("f")(_f("e")(d))))])}`
-    )
-  })
-
-  it('generate filters with no arguments', () => {
-    assertCodegen(
-      '<div>{{ d | e() }}</div>',
-      `with(this){return _c('div',[_v(_s(_f("e")(d)))])}`
-    )
-  })
-
-  it('generate v-for directive', () => {
-    assertCodegen(
-      '<div><li v-for="item in items" :key="item.uid"></li></div>',
-      `with(this){return _c('div',_l((items),function(item){return _c('li',{key:item.uid})}),0)}`
-    )
-    // iterator syntax
-    assertCodegen(
-      '<div><li v-for="(item, i) in items"></li></div>',
-      `with(this){return _c('div',_l((items),function(item,i){return _c('li')}),0)}`
-    )
-    assertCodegen(
-      '<div><li v-for="(item, key, index) in items"></li></div>',
-      `with(this){return _c('div',_l((items),function(item,key,index){return _c('li')}),0)}`
-    )
-    // destructuring
-    assertCodegen(
-      '<div><li v-for="{ a, b } in items"></li></div>',
-      `with(this){return _c('div',_l((items),function({ a, b }){return _c('li')}),0)}`
-    )
-    assertCodegen(
-      '<div><li v-for="({ a, b }, key, index) in items"></li></div>',
-      `with(this){return _c('div',_l((items),function({ a, b },key,index){return _c('li')}),0)}`
-    )
-    // v-for with extra element
-    assertCodegen(
-      '<div><p></p><li v-for="item in items"></li></div>',
-      `with(this){return _c('div',[_c('p'),_l((items),function(item){return _c('li')})],2)}`
-    )
-  })
-
-  it('generate v-if directive', () => {
-    assertCodegen(
-      '<p v-if="show">hello</p>',
-      `with(this){return (show)?_c('p',[_v("hello")]):_e()}`
-    )
-  })
-
-  it('generate v-else directive', () => {
-    assertCodegen(
-      '<div><p v-if="show">hello</p><p v-else>world</p></div>',
-      `with(this){return _c('div',[(show)?_c('p',[_v("hello")]):_c('p',[_v("world")])])}`
-    )
-  })
-
-  it('generate v-else-if directive', () => {
-    assertCodegen(
-      '<div><p v-if="show">hello</p><p v-else-if="hide">world</p></div>',
-      `with(this){return _c('div',[(show)?_c('p',[_v("hello")]):(hide)?_c('p',[_v("world")]):_e()])}`
-    )
-  })
-
-  it('generate v-else-if with v-else directive', () => {
-    assertCodegen(
-      '<div><p v-if="show">hello</p><p v-else-if="hide">world</p><p v-else>bye</p></div>',
-      `with(this){return _c('div',[(show)?_c('p',[_v("hello")]):(hide)?_c('p',[_v("world")]):_c('p',[_v("bye")])])}`
-    )
-  })
-
-  it('generate multi v-else-if with v-else directive', () => {
-    assertCodegen(
-      '<div><p v-if="show">hello</p><p v-else-if="hide">world</p><p v-else-if="3">elseif</p><p v-else>bye</p></div>',
-      `with(this){return _c('div',[(show)?_c('p',[_v("hello")]):(hide)?_c('p',[_v("world")]):(3)?_c('p',[_v("elseif")]):_c('p',[_v("bye")])])}`
-    )
-  })
-
-  it('generate ref', () => {
-    assertCodegen(
-      '<p ref="component1"></p>',
-      `with(this){return _c('p',{ref:"component1"})}`
-    )
-  })
-
-  it('generate ref on v-for', () => {
-    assertCodegen(
-      '<ul><li v-for="item in items" ref="component1"></li></ul>',
-      `with(this){return _c('ul',_l((items),function(item){return _c('li',{ref:"component1",refInFor:true})}),0)}`
-    )
-  })
-
-  it('generate v-bind directive', () => {
-    assertCodegen(
-      '<p v-bind="test"></p>',
-      `with(this){return _c('p',_b({},'p',test,false))}`
-    )
-  })
-
-  it('generate v-bind with prop directive', () => {
-    assertCodegen(
-      '<p v-bind.prop="test"></p>',
-      `with(this){return _c('p',_b({},'p',test,true))}`
-    )
-  })
-
-  it('generate v-bind directive with sync modifier', () => {
-    assertCodegen(
-      '<p v-bind.sync="test"></p>',
-      `with(this){return _c('p',_b({},'p',test,false,true))}`
-    )
-  })
-
-  it('generate v-model directive', () => {
-    assertCodegen(
-      '<input v-model="test">',
-      `with(this){return _c('input',{directives:[{name:"model",rawName:"v-model",value:(test),expression:"test"}],domProps:{"value":(test)},on:{"input":function($event){if($event.target.composing)return;test=$event.target.value}}})}`
-    )
-  })
-
-  it('generate multiline v-model directive', () => {
-    assertCodegen(
-      '<input v-model="\n test \n">',
-      `with(this){return _c('input',{directives:[{name:"model",rawName:"v-model",value:(\n test \n),expression:"\\n test \\n"}],domProps:{"value":(\n test \n)},on:{"input":function($event){if($event.target.composing)return;\n test \n=$event.target.value}}})}`
-    )
-  })
-
-  it('generate multiline v-model directive on custom component', () => {
-    assertCodegen(
-      '<my-component v-model="\n test \n" />',
-      `with(this){return _c('my-component',{model:{value:(\n test \n),callback:function ($$v) {\n test \n=$$v},expression:"\\n test \\n"}})}`
-    )
-  })
-
-  it('generate template tag', () => {
-    assertCodegen(
-      '<div><template><p>{{hello}}</p></template></div>',
-      `with(this){return _c('div',[[_c('p',[_v(_s(hello))])]],2)}`
-    )
-  })
-
-  it('generate single slot', () => {
-    assertCodegen(
-      '<div><slot></slot></div>',
-      `with(this){return _c('div',[_t("default")],2)}`
-    )
-  })
-
-  it('generate named slot', () => {
-    assertCodegen(
-      '<div><slot name="one"></slot></div>',
-      `with(this){return _c('div',[_t("one")],2)}`
-    )
-  })
-
-  it('generate slot fallback content', () => {
-    assertCodegen(
-      '<div><slot><div>hi</div></slot></div>',
-      `with(this){return _c('div',[_t("default",[_c('div',[_v("hi")])])],2)}`
-    )
-  })
-
-  it('generate slot target', () => {
-    assertCodegen(
-      '<p slot="one">hello world</p>',
-      `with(this){return _c('p',{attrs:{"slot":"one"},slot:"one"},[_v("hello world")])}`
-    )
-  })
-
-  it('generate scoped slot', () => {
-    assertCodegen(
-      '<foo><template slot-scope="bar">{{ bar }}</template></foo>',
-      `with(this){return _c('foo',{scopedSlots:_u([{key:"default",fn:function(bar){return [_v(_s(bar))]}}])})}`
-    )
-    assertCodegen(
-      '<foo><div slot-scope="bar">{{ bar }}</div></foo>',
-      `with(this){return _c('foo',{scopedSlots:_u([{key:"default",fn:function(bar){return _c('div',{},[_v(_s(bar))])}}])})}`
-    )
-  })
-
-  it('generate named scoped slot', () => {
-    assertCodegen(
-      '<foo><template slot="foo" slot-scope="bar">{{ bar }}</template></foo>',
-      `with(this){return _c('foo',{scopedSlots:_u([{key:"foo",fn:function(bar){return [_v(_s(bar))]}}])})}`
-    )
-    assertCodegen(
-      '<foo><div slot="foo" slot-scope="bar">{{ bar }}</div></foo>',
-      `with(this){return _c('foo',{scopedSlots:_u([{key:"foo",fn:function(bar){return _c('div',{},[_v(_s(bar))])}}])})}`
-    )
-  })
-
-  it('generate dynamic scoped slot', () => {
-    assertCodegen(
-      '<foo><template :slot="foo" slot-scope="bar">{{ bar }}</template></foo>',
-      `with(this){return _c('foo',{scopedSlots:_u([{key:foo,fn:function(bar){return [_v(_s(bar))]}}],null,true)})}`
-    )
-  })
-
-  it('generate scoped slot with multiline v-if', () => {
-    assertCodegen(
-      '<foo><template v-if="\nshow\n" slot-scope="bar">{{ bar }}</template></foo>',
-      `with(this){return _c('foo',{scopedSlots:_u([{key:"default",fn:function(bar){return (\nshow\n)?[_v(_s(bar))]:undefined}}],null,true)})}`
-    )
-    assertCodegen(
-      '<foo><div v-if="\nshow\n" slot="foo" slot-scope="bar">{{ bar }}</div></foo>',
-      `with(this){return _c(\'foo\',{scopedSlots:_u([{key:"foo",fn:function(bar){return (\nshow\n)?_c(\'div\',{},[_v(_s(bar))]):_e()}}],null,true)})}`
-    )
-  })
-
-  it('generate scoped slot with new slot syntax', () => {
-    assertCodegen(
-      '<foo><template v-if="show" #default="bar">{{ bar }}</template></foo>',
-      `with(this){return _c('foo',{scopedSlots:_u([(show)?{key:"default",fn:function(bar){return [_v(_s(bar))]}}:null],null,true)})}`
-    )
-  })
-
-  it('generate class binding', () => {
-    // static
-    assertCodegen(
-      '<p class="class1">hello world</p>',
-      `with(this){return _c('p',{staticClass:"class1"},[_v("hello world")])}`,
-    )
-    // dynamic
-    assertCodegen(
-      '<p :class="class1">hello world</p>',
-      `with(this){return _c('p',{class:class1},[_v("hello world")])}`
-    )
-  })
-
-  it('generate style binding', () => {
-    assertCodegen(
-      '<p :style="error">hello world</p>',
-      `with(this){return _c('p',{style:(error)},[_v("hello world")])}`
-    )
-  })
-
-  it('generate v-show directive', () => {
-    assertCodegen(
-      '<p v-show="shown">hello world</p>',
-      `with(this){return _c('p',{directives:[{name:"show",rawName:"v-show",value:(shown),expression:"shown"}]},[_v("hello world")])}`
-    )
-  })
-
-  it('generate DOM props with v-bind directive', () => {
-    // input + value
-    assertCodegen(
-      '<input :value="msg">',
-      `with(this){return _c('input',{domProps:{"value":msg}})}`
-    )
-    // non input
-    assertCodegen(
-      '<p :value="msg"/>',
-      `with(this){return _c('p',{attrs:{"value":msg}})}`
-    )
-  })
-
-  it('generate attrs with v-bind directive', () => {
-    assertCodegen(
-      '<input :name="field1">',
-      `with(this){return _c('input',{attrs:{"name":field1}})}`
-    )
-  })
-
-  it('generate static attrs', () => {
-    assertCodegen(
-      '<input name="field1">',
-      `with(this){return _c('input',{attrs:{"name":"field1"}})}`
-    )
-  })
-
-  it('generate events with v-on directive', () => {
-    assertCodegen(
-      '<input @input="onInput">',
-      `with(this){return _c('input',{on:{"input":onInput}})}`
-    )
-  })
-
-  it('generate events with method call', () => {
-    assertCodegen(
-      '<input @input="onInput($event);">',
-      `with(this){return _c('input',{on:{"input":function($event){return onInput($event);}}})}`
-    )
-    // empty arguments
-    assertCodegen(
-      '<input @input="onInput();">',
-      `with(this){return _c('input',{on:{"input":function($event){return onInput();}}})}`
-    )
-    // without semicolon
-    assertCodegen(
-      '<input @input="onInput($event)">',
-      `with(this){return _c('input',{on:{"input":function($event){return onInput($event)}}})}`
-    )
-    // multiple args
-    assertCodegen(
-      '<input @input="onInput($event, \'abc\', 5);">',
-      `with(this){return _c('input',{on:{"input":function($event){return onInput($event, 'abc', 5);}}})}`
-    )
-    // expression in args
-    assertCodegen(
-      '<input @input="onInput($event, 2+2);">',
-      `with(this){return _c('input',{on:{"input":function($event){return onInput($event, 2+2);}}})}`
-    )
-    // tricky symbols in args
-    assertCodegen(
-      `<input @input="onInput(');[\\'());');">`,
-      `with(this){return _c('input',{on:{"input":function($event){onInput(');[\\'());');}}})}`
-    )
-  })
-
-  it('generate events with multiple statements', () => {
-    // normal function
-    assertCodegen(
-      '<input @input="onInput1();onInput2()">',
-      `with(this){return _c('input',{on:{"input":function($event){onInput1();onInput2()}}})}`
-    )
-    // function with multiple args
-    assertCodegen(
-      '<input @input="onInput1($event, \'text\');onInput2(\'text2\', $event)">',
-      `with(this){return _c('input',{on:{"input":function($event){onInput1($event, 'text');onInput2('text2', $event)}}})}`
-    )
-  })
-
-  it('generate events with keycode', () => {
-    assertCodegen(
-      '<input @input.enter="onInput">',
-      `with(this){return _c('input',{on:{"input":function($event){if(!$event.type.indexOf('key')&&_k($event.keyCode,"enter",13,$event.key,"Enter"))return null;return onInput($event)}}})}`
-    )
-    // multiple keycodes (delete)
-    assertCodegen(
-      '<input @input.delete="onInput">',
-      `with(this){return _c('input',{on:{"input":function($event){if(!$event.type.indexOf('key')&&_k($event.keyCode,"delete",[8,46],$event.key,["Backspace","Delete","Del"]))return null;return onInput($event)}}})}`
-    )
-    // multiple keycodes (esc)
-    assertCodegen(
-      '<input @input.esc="onInput">',
-      `with(this){return _c('input',{on:{"input":function($event){if(!$event.type.indexOf('key')&&_k($event.keyCode,"esc",27,$event.key,["Esc","Escape"]))return null;return onInput($event)}}})}`
-    )
-    // multiple keycodes (space)
-    assertCodegen(
-      '<input @input.space="onInput">',
-      `with(this){return _c('input',{on:{"input":function($event){if(!$event.type.indexOf('key')&&_k($event.keyCode,"space",32,$event.key,[" ","Spacebar"]))return null;return onInput($event)}}})}`
-    )
-    // multiple keycodes (chained)
-    assertCodegen(
-      '<input @keydown.enter.delete="onInput">',
-      `with(this){return _c('input',{on:{"keydown":function($event){if(!$event.type.indexOf('key')&&_k($event.keyCode,"enter",13,$event.key,"Enter")&&_k($event.keyCode,"delete",[8,46],$event.key,["Backspace","Delete","Del"]))return null;return onInput($event)}}})}`
-    )
-    // number keycode
-    assertCodegen(
-      '<input @input.13="onInput">',
-      `with(this){return _c('input',{on:{"input":function($event){if(!$event.type.indexOf('key')&&$event.keyCode!==13)return null;return onInput($event)}}})}`
-    )
-    // custom keycode
-    assertCodegen(
-      '<input @input.custom="onInput">',
-      `with(this){return _c('input',{on:{"input":function($event){if(!$event.type.indexOf('key')&&_k($event.keyCode,"custom",undefined,$event.key,undefined))return null;return onInput($event)}}})}`
-    )
-  })
-
-  it('generate events with generic modifiers', () => {
-    assertCodegen(
-      '<input @input.stop="onInput">',
-      `with(this){return _c('input',{on:{"input":function($event){$event.stopPropagation();return onInput($event)}}})}`
-    )
-    assertCodegen(
-      '<input @input.prevent="onInput">',
-      `with(this){return _c('input',{on:{"input":function($event){$event.preventDefault();return onInput($event)}}})}`
-    )
-    assertCodegen(
-      '<input @input.self="onInput">',
-      `with(this){return _c('input',{on:{"input":function($event){if($event.target !== $event.currentTarget)return null;return onInput($event)}}})}`
-    )
-  })
-
-  // GitHub Issues #5146
-  it('generate events with generic modifiers and keycode correct order', () => {
-    assertCodegen(
-      '<input @keydown.enter.prevent="onInput">',
-      `with(this){return _c('input',{on:{"keydown":function($event){if(!$event.type.indexOf('key')&&_k($event.keyCode,"enter",13,$event.key,"Enter"))return null;$event.preventDefault();return onInput($event)}}})}`
-    )
-
-    assertCodegen(
-      '<input @keydown.enter.stop="onInput">',
-      `with(this){return _c('input',{on:{"keydown":function($event){if(!$event.type.indexOf('key')&&_k($event.keyCode,"enter",13,$event.key,"Enter"))return null;$event.stopPropagation();return onInput($event)}}})}`
-    )
-  })
-
-  it('generate events with mouse event modifiers', () => {
-    assertCodegen(
-      '<input @click.ctrl="onClick">',
-      `with(this){return _c('input',{on:{"click":function($event){if(!$event.ctrlKey)return null;return onClick($event)}}})}`
-    )
-    assertCodegen(
-      '<input @click.shift="onClick">',
-      `with(this){return _c('input',{on:{"click":function($event){if(!$event.shiftKey)return null;return onClick($event)}}})}`
-    )
-    assertCodegen(
-      '<input @click.alt="onClick">',
-      `with(this){return _c('input',{on:{"click":function($event){if(!$event.altKey)return null;return onClick($event)}}})}`
-    )
-    assertCodegen(
-      '<input @click.meta="onClick">',
-      `with(this){return _c('input',{on:{"click":function($event){if(!$event.metaKey)return null;return onClick($event)}}})}`
-    )
-    assertCodegen(
-      '<input @click.exact="onClick">',
-      `with(this){return _c('input',{on:{"click":function($event){if($event.ctrlKey||$event.shiftKey||$event.altKey||$event.metaKey)return null;return onClick($event)}}})}`
-    )
-    assertCodegen(
-      '<input @click.ctrl.exact="onClick">',
-      `with(this){return _c('input',{on:{"click":function($event){if(!$event.ctrlKey)return null;if($event.shiftKey||$event.altKey||$event.metaKey)return null;return onClick($event)}}})}`
-    )
-  })
-
-  it('generate events with multiple modifiers', () => {
-    assertCodegen(
-      '<input @input.stop.prevent.self="onInput">',
-      `with(this){return _c('input',{on:{"input":function($event){$event.stopPropagation();$event.preventDefault();if($event.target !== $event.currentTarget)return null;return onInput($event)}}})}`
-    )
-  })
-
-  it('generate events with capture modifier', () => {
-    assertCodegen(
-      '<input @input.capture="onInput">',
-      `with(this){return _c('input',{on:{"!input":function($event){return onInput($event)}}})}`
-    )
-  })
-
-  it('generate events with once modifier', () => {
-    assertCodegen(
-      '<input @input.once="onInput">',
-      `with(this){return _c('input',{on:{"~input":function($event){return onInput($event)}}})}`
-    )
-  })
-
-  it('generate events with capture and once modifier', () => {
-    assertCodegen(
-      '<input @input.capture.once="onInput">',
-      `with(this){return _c('input',{on:{"~!input":function($event){return onInput($event)}}})}`
-    )
-  })
-
-  it('generate events with once and capture modifier', () => {
-    assertCodegen(
-      '<input @input.once.capture="onInput">',
-      `with(this){return _c('input',{on:{"~!input":function($event){return onInput($event)}}})}`
-    )
-  })
-
-  it('generate events with inline statement', () => {
-    assertCodegen(
-      '<input @input="current++">',
-      `with(this){return _c('input',{on:{"input":function($event){current++}}})}`
-    )
-  })
-
-  it('generate events with inline function expression', () => {
-    // normal function
-    assertCodegen(
-      '<input @input="function () { current++ }">',
-      `with(this){return _c('input',{on:{"input":function () { current++ }}})}`
-    )
-    // normal named function
-    assertCodegen(
-      '<input @input="function fn () { current++ }">',
-      `with(this){return _c('input',{on:{"input":function fn () { current++ }}})}`
-    )
-    // arrow with no args
-    assertCodegen(
-      '<input @input="()=>current++">',
-      `with(this){return _c('input',{on:{"input":()=>current++}})}`
-    )
-    // arrow with parens, single arg
-    assertCodegen(
-      '<input @input="(e) => current++">',
-      `with(this){return _c('input',{on:{"input":(e) => current++}})}`
-    )
-    // arrow with parens, multi args
-    assertCodegen(
-      '<input @input="(a, b, c) => current++">',
-      `with(this){return _c('input',{on:{"input":(a, b, c) => current++}})}`
-    )
-    // arrow with destructuring
-    assertCodegen(
-      '<input @input="({ a, b }) => current++">',
-      `with(this){return _c('input',{on:{"input":({ a, b }) => current++}})}`
-    )
-    // arrow single arg no parens
-    assertCodegen(
-      '<input @input="e=>current++">',
-      `with(this){return _c('input',{on:{"input":e=>current++}})}`
-    )
-    // with modifiers
-    assertCodegen(
-      `<input @keyup.enter="e=>current++">`,
-      `with(this){return _c('input',{on:{"keyup":function($event){if(!$event.type.indexOf('key')&&_k($event.keyCode,"enter",13,$event.key,"Enter"))return null;return (e=>current++)($event)}}})}`
-    )
-  })
-
-  // #3893
-  it('should not treat handler with unexpected whitespace as inline statement', () => {
-    assertCodegen(
-      '<input @input=" onInput ">',
-      `with(this){return _c('input',{on:{"input":onInput}})}`
-    )
-  })
-
-  it('generate unhandled events', () => {
-    assertCodegen(
-      '<input @input="current++">',
-      `with(this){return _c('input',{on:{"input":function(){}}})}`,
-      ast => {
-        ast.events.input = undefined
-      }
-    )
-  })
-
-  it('generate multiple event handlers', () => {
-    assertCodegen(
-      '<input @input="current++" @input.stop="onInput">',
-      `with(this){return _c('input',{on:{"input":[function($event){current++},function($event){$event.stopPropagation();return onInput($event)}]}})}`
-    )
-  })
-
-  it('generate component', () => {
-    assertCodegen(
-      '<my-component name="mycomponent1" :msg="msg" @notify="onNotify"><div>hi</div></my-component>',
-      `with(this){return _c('my-component',{attrs:{"name":"mycomponent1","msg":msg},on:{"notify":onNotify}},[_c('div',[_v("hi")])])}`
-    )
-  })
-
-  it('generate svg component with children', () => {
-    assertCodegen(
-      '<svg><my-comp><circle :r="10"></circle></my-comp></svg>',
-      `with(this){return _c('svg',[_c('my-comp',[_c('circle',{attrs:{"r":10}})])],1)}`
-    )
-  })
-
-  it('generate is attribute', () => {
-    assertCodegen(
-      '<div is="component1"></div>',
-      `with(this){return _c("component1",{tag:"div"})}`
-    )
-    assertCodegen(
-      '<div :is="component1"></div>',
-      `with(this){return _c(component1,{tag:"div"})}`
-    )
-    // maybe a component and normalize type should be 1
-    assertCodegen(
-      '<div><div is="component1"></div></div>',
-      `with(this){return _c('div',[_c("component1",{tag:"div"})],1)}`
-    )
-  })
-
-  it('generate component with inline-template', () => {
-    // have "inline-template'"
-    assertCodegen(
-      '<my-component inline-template><p><span>hello world</span></p></my-component>',
-      `with(this){return _c('my-component',{inlineTemplate:{render:function(){with(this){return _m(0)}},staticRenderFns:[function(){with(this){return _c('p',[_c('span',[_v("hello world")])])}}]}})}`
-    )
-    // "have inline-template attrs, but not having exactly one child element
-    assertCodegen(
-      '<my-component inline-template><hr><hr></my-component>',
-      `with(this){return _c('my-component',{inlineTemplate:{render:function(){with(this){return _c('hr')}},staticRenderFns:[]}})}`
-    )
-    assertCodegen(
-      '<my-component inline-template></my-component>',
-      `with(this){return _c('my-component',{})}`
-    )
-    // have "is" attribute
-    assertCodegen(
-      '<div is="myComponent" inline-template><div></div></div>',
-      `with(this){return _c("myComponent",{tag:"div",inlineTemplate:{render:function(){with(this){return _c('div')}},staticRenderFns:[]}})}`
-    )
-    assertCodegen(
-      '<div is="myComponent" inline-template></div>',
-      `with(this){return _c("myComponent",{tag:"div"})}`
-    )
-    expect('Inline-template components must have exactly one child element.').toHaveBeenWarned()
-    expect(console.error.calls.count()).toBe(3)
-  })
-
-  it('generate static trees inside v-for', () => {
-    assertCodegen(
-      `<div><div v-for="i in 10"><p><span></span></p></div></div>`,
-      `with(this){return _c('div',_l((10),function(i){return _c('div',[_m(0,true)])}),0)}`,
-      [`with(this){return _c('p',[_c('span')])}`]
-    )
-  })
-
-  it('generate component with v-for', () => {
-    // normalize type: 2
-    assertCodegen(
-      '<div><child></child><template v-for="item in list">{{ item }}</template></div>',
-      `with(this){return _c('div',[_c('child'),_l((list),function(item){return [_v(_s(item))]})],2)}`
-    )
-  })
-
-  it('generate component with comment', () => {
-    const options = extend({
-      comments: true
-    }, baseOptions)
-    const template = '<div><!--comment--></div>'
-    const generatedCode = `with(this){return _c('div',[_e("comment")])}`
-
-    const ast = parse(template, options)
-    optimize(ast, options)
-    const res = generate(ast, options)
-    expect(res.render).toBe(generatedCode)
-  })
-
-  // #6150
-  it('generate comments with special characters', () => {
-    const options = extend({
-      comments: true
-    }, baseOptions)
-    const template = '<div><!--\n\'comment\'\n--></div>'
-    const generatedCode = `with(this){return _c('div',[_e("\\n'comment'\\n")])}`
-
-    const ast = parse(template, options)
-    optimize(ast, options)
-    const res = generate(ast, options)
-    expect(res.render).toBe(generatedCode)
-  })
-
-  // #8041
-  it('does not squash templates inside v-pre', () => {
-    const template = '<div v-pre><template><p>{{msg}}</p></template></div>'
-    const generatedCode = `with(this){return _m(0)}`
-    const renderFn = `with(this){return _c('div',{pre:true},[_c('template',[_c('p',[_v("{{msg}}")])])],2)}`
-    const ast = parse(template, baseOptions)
-    optimize(ast, baseOptions)
-    const res = generate(ast, baseOptions)
-    expect(res.render).toBe(generatedCode)
-    expect(res.staticRenderFns).toEqual([renderFn])
-  })
-
-  it('not specified ast type', () => {
-    const res = generate(null, baseOptions)
-    expect(res.render).toBe(`with(this){return _c("div")}`)
-    expect(res.staticRenderFns).toEqual([])
-  })
-
-  it('not specified directives option', () => {
-    assertCodegen(
-      '<p v-if="show">hello world</p>',
-      `with(this){return (show)?_c('p',[_v("hello world")]):_e()}`,
-      { isReservedTag }
-    )
-  })
-
-  // #9142
-  it('should compile single v-for component inside template', () => {
-    assertCodegen(
-      `<div><template v-if="ok"><foo v-for="i in 1" :key="i"></foo></template></div>`,
-      `with(this){return _c('div',[(ok)?_l((1),function(i){return _c('foo',{key:i})}):_e()],2)}`
-    )
-  })
-})
-/* eslint-enable quotes */
diff --git a/1.Vue/test/unit/modules/compiler/compiler-options.spec.js b/1.Vue/test/unit/modules/compiler/compiler-options.spec.js
deleted file mode 100644
index a0cfcdd..0000000
--- a/1.Vue/test/unit/modules/compiler/compiler-options.spec.js
+++ /dev/null
@@ -1,156 +0,0 @@
-import Vue from 'vue'
-import { compile } from 'web/compiler'
-import { getAndRemoveAttr } from 'compiler/helpers'
-
-describe('compile options', () => {
-  it('should be compiled', () => {
-    const { render, staticRenderFns, errors } = compile(`
-      <div>
-        <input type="text" v-model="msg" required max="8" v-validate:field1.group1.group2>
-      </div>
-    `, {
-      directives: {
-        validate (el, dir) {
-          if (dir.name === 'validate' && dir.arg) {
-            el.validate = {
-              field: dir.arg,
-              groups: dir.modifiers ? Object.keys(dir.modifiers) : []
-            }
-          }
-        }
-      },
-      modules: [
-        {
-          transformNode (el) {
-            el.validators = el.validators || []
-            const validators = ['required', 'min', 'max', 'pattern', 'maxlength', 'minlength']
-            validators.forEach(name => {
-              const rule = getAndRemoveAttr(el, name)
-              if (rule !== undefined) {
-                el.validators.push({ name, rule })
-              }
-            })
-          },
-          genData (el) {
-            let data = ''
-            if (el.validate) {
-              data += `validate:${JSON.stringify(el.validate)},`
-            }
-            if (el.validators) {
-              data += `validators:${JSON.stringify(el.validators)},`
-            }
-            return data
-          },
-          transformCode (el, code) {
-            // check
-            if (!el.validate || !el.validators) {
-              return code
-            }
-            // setup validation result props
-            const result = { dirty: false } // define something other prop
-            el.validators.forEach(validator => {
-              result[validator.name] = null
-            })
-            // generate code
-            return `_c('validate',{props:{
-              field:${JSON.stringify(el.validate.field)},
-              groups:${JSON.stringify(el.validate.groups)},
-              validators:${JSON.stringify(el.validators)},
-              result:${JSON.stringify(result)},
-              child:${code}}
-            })`
-          }
-        }
-      ]
-    })
-    expect(render).not.toBeUndefined()
-    expect(staticRenderFns).toEqual([])
-    expect(errors).toEqual([])
-
-    const renderFn = new Function(render)
-    const vm = new Vue({
-      data: {
-        msg: 'hello'
-      },
-      components: {
-        validate: {
-          props: ['field', 'groups', 'validators', 'result', 'child'],
-          render (h) {
-            return this.child
-          },
-          computed: {
-            valid () {
-              let ret = true
-              for (let i = 0; i < this.validators.length; i++) {
-                const { name } = this.validators[i]
-                if (!this.result[name]) {
-                  ret = false
-                  break
-                }
-              }
-              return ret
-            }
-          },
-          mounted () {
-            // initialize validation
-            const value = this.$el.value
-            this.validators.forEach(validator => {
-              const ret = this[validator.name](value, validator.rule)
-              this.result[validator.name] = ret
-            })
-          },
-          methods: {
-            // something validators logic
-            required (val) {
-              return val.length > 0
-            },
-            max (val, rule) {
-              return !(parseInt(val, 10) > parseInt(rule, 10))
-            }
-          }
-        }
-      },
-      render: renderFn,
-      staticRenderFns
-    }).$mount()
-    expect(vm.$el.innerHTML).toBe('<input type="text">')
-    expect(vm.$children[0].valid).toBe(true)
-  })
-
-  it('should collect errors', () => {
-    let compiled = compile('hello')
-    expect(compiled.errors.length).toBe(1)
-    expect(compiled.errors[0]).toContain('root element')
-
-    compiled = compile('<div v-if="a----">{{ b++++ }}</div>')
-    expect(compiled.errors.length).toBe(2)
-    expect(compiled.errors[0]).toContain('Raw expression: v-if="a----"')
-    expect(compiled.errors[1]).toContain('Raw expression: {{ b++++ }}')
-  })
-
-  it('should collect errors with source range', () => {
-    let compiled = compile('hello', { outputSourceRange: true })
-    expect(compiled.errors.length).toBe(1)
-    expect(compiled.errors[0].start).toBe(0)
-    expect(compiled.errors[0].end).toBeUndefined()
-
-    compiled = compile('<div v-if="a----">{{ b++++ }}</div>', { outputSourceRange: true })
-    expect(compiled.errors.length).toBe(2)
-    expect(compiled.errors[0].start).toBe(5)
-    expect(compiled.errors[0].end).toBe(17)
-    expect(compiled.errors[1].start).toBe(18)
-    expect(compiled.errors[1].end).toBe(29)
-
-    compiled = compile('<div><span></div>', { outputSourceRange: true })
-    expect(compiled.errors.length).toBe(1)
-    expect(compiled.errors[0].start).toBe(5)
-    expect(compiled.errors[0].end).toBe(11)
-  })
-
-  it('should collect source range for binding keys', () => {
-    const compiled = compile('<div><slot v-bind:key="key" /></div>', { outputSourceRange: true })
-    expect(compiled.errors.length).toBe(1)
-    expect(compiled.errors[0].start).toBe(11)
-    expect(compiled.errors[0].end).toBe(27)
-  })
-})
diff --git a/1.Vue/test/unit/modules/compiler/optimizer.spec.js b/1.Vue/test/unit/modules/compiler/optimizer.spec.js
deleted file mode 100644
index c807908..0000000
--- a/1.Vue/test/unit/modules/compiler/optimizer.spec.js
+++ /dev/null
@@ -1,257 +0,0 @@
-import { parse } from 'compiler/parser/index'
-import { extend } from 'shared/util'
-import { optimize } from 'compiler/optimizer'
-import { baseOptions } from 'web/compiler/options'
-
-describe('optimizer', () => {
-  it('simple', () => {
-    const ast = parse('<h1 id="section1"><span>hello world</span></h1>', baseOptions)
-    optimize(ast, baseOptions)
-    expect(ast.static).toBe(true) // h1
-    expect(ast.staticRoot).toBe(true)
-    expect(ast.children[0].static).toBe(true) // span
-  })
-
-  it('simple with comment', () => {
-    const options = extend({
-      comments: true
-    }, baseOptions)
-    const ast = parse('<h1 id="section1"><span>hello world</span><!--comment--></h1>', options)
-    optimize(ast, options)
-    expect(ast.static).toBe(true) // h1
-    expect(ast.staticRoot).toBe(true)
-    expect(ast.children.length).toBe(2)
-    expect(ast.children[0].static).toBe(true) // span
-    expect(ast.children[1].static).toBe(true) // comment
-  })
-
-  it('skip simple nodes', () => {
-    const ast = parse('<h1 id="section1">hello</h1>', baseOptions)
-    optimize(ast, baseOptions)
-    expect(ast.static).toBe(true)
-    expect(ast.staticRoot).toBe(false) // this is too simple to warrant a static tree
-  })
-
-  it('interpolation', () => {
-    const ast = parse('<h1>{{msg}}</h1>', baseOptions)
-    optimize(ast, baseOptions)
-    expect(ast.static).toBe(false) // h1
-    expect(ast.children[0].static).toBe(false) // text node with interpolation
-  })
-
-  it('nested elements', () => {
-    const ast = parse('<ul><li>hello</li><li>world</li></ul>', baseOptions)
-    optimize(ast, baseOptions)
-    // ul
-    expect(ast.static).toBe(true)
-    expect(ast.staticRoot).toBe(true)
-    // li
-    expect(ast.children[0].static).toBe(true) // first
-    expect(ast.children[1].static).toBe(true) // second
-    // text node inside li
-    expect(ast.children[0].children[0].static).toBe(true) // first
-    expect(ast.children[1].children[0].static).toBe(true) // second
-  })
-
-  it('nested complex elements', () => {
-    const ast = parse('<ul><li>{{msg1}}</li><li>---</li><li>{{msg2}}</li></ul>', baseOptions)
-    optimize(ast, baseOptions)
-    // ul
-    expect(ast.static).toBe(false) // ul
-    // li
-    expect(ast.children[0].static).toBe(false) // first
-    expect(ast.children[1].static).toBe(true) // second
-    expect(ast.children[2].static).toBe(false) // third
-    // text node inside li
-    expect(ast.children[0].children[0].static).toBe(false) // first
-    expect(ast.children[1].children[0].static).toBe(true) // second
-    expect(ast.children[2].children[0].static).toBe(false) // third
-  })
-
-  it('v-if directive', () => {
-    const ast = parse('<div id="section1" v-if="show"><p><span>hello world</span></p></div>', baseOptions)
-    optimize(ast, baseOptions)
-    expect(ast.static).toBe(false)
-    expect(ast.children[0].static).toBe(true)
-  })
-
-  it('v-else directive', () => {
-    const ast = parse('<div><p v-if="show">hello world</p><div v-else><p><span>foo bar</span></p></div></div>', baseOptions)
-    optimize(ast, baseOptions)
-    expect(ast.static).toBe(false)
-    expect(ast.children[0].static).toBe(false)
-    expect(ast.children[0].ifConditions[0].block.static).toBe(false)
-    expect(ast.children[0].ifConditions[1].block.static).toBe(false)
-    expect(ast.children[0].ifConditions[0].block.children[0].static).toBe(true)
-    expect(ast.children[0].ifConditions[1].block.children[0].static).toBe(true)
-  })
-
-  it('v-pre directive', () => {
-    const ast = parse('<ul v-pre><li>{{msg}}</li><li>world</li></ul>', baseOptions)
-    optimize(ast, baseOptions)
-    expect(ast.static).toBe(true)
-    expect(ast.staticRoot).toBe(true)
-    expect(ast.children[0].static).toBe(true)
-    expect(ast.children[1].static).toBe(true)
-    expect(ast.children[0].children[0].static).toBe(true)
-    expect(ast.children[1].children[0].static).toBe(true)
-  })
-
-  it('v-for directive', () => {
-    const ast = parse('<ul><li v-for="item in items">hello world {{$index}}</li></ul>', baseOptions)
-    optimize(ast, baseOptions)
-    // ul
-    expect(ast.static).toBe(false)
-    // li with v-for
-    expect(ast.children[0].static).toBe(false)
-    expect(ast.children[0].children[0].static).toBe(false)
-  })
-
-  it('v-once directive', () => {
-    const ast = parse('<p v-once>{{msg}}</p>', baseOptions)
-    optimize(ast, baseOptions)
-    expect(ast.static).toBe(false) // p
-    expect(ast.children[0].static).toBe(false) // text node
-  })
-
-  it('single slot', () => {
-    const ast = parse('<div><slot>hello</slot></div>', baseOptions)
-    optimize(ast, baseOptions)
-    expect(ast.children[0].static).toBe(false) // slot
-    expect(ast.children[0].children[0].static).toBe(true) // text node
-  })
-
-  it('named slot', () => {
-    const ast = parse('<div><slot name="one">hello world</slot></div>', baseOptions)
-    optimize(ast, baseOptions)
-    expect(ast.children[0].static).toBe(false) // slot
-    expect(ast.children[0].children[0].static).toBe(true) // text node
-  })
-
-  it('slot target', () => {
-    const ast = parse('<p slot="one">hello world</p>', baseOptions)
-    optimize(ast, baseOptions)
-    expect(ast.static).toBe(false) // slot
-    expect(ast.children[0].static).toBe(true) // text node
-  })
-
-  it('component', () => {
-    const ast = parse('<my-component></my-component>', baseOptions)
-    optimize(ast, baseOptions)
-    expect(ast.static).toBe(false) // component
-  })
-
-  it('component for inline-template', () => {
-    const ast = parse('<my-component inline-template><p>hello world</p><p>{{msg}}</p></my-component>', baseOptions)
-    optimize(ast, baseOptions)
-    // component
-    expect(ast.static).toBe(false) // component
-    // p
-    expect(ast.children[0].static).toBe(true) // first
-    expect(ast.children[1].static).toBe(false) // second
-    // text node inside p
-    expect(ast.children[0].children[0].static).toBe(true) // first
-    expect(ast.children[1].children[0].static).toBe(false) // second
-  })
-
-  it('class binding', () => {
-    const ast = parse('<p :class="class1">hello world</p>', baseOptions)
-    optimize(ast, baseOptions)
-    expect(ast.static).toBe(false)
-    expect(ast.children[0].static).toBe(true)
-  })
-
-  it('style binding', () => {
-    const ast = parse('<p :style="error">{{msg}}</p>', baseOptions)
-    optimize(ast, baseOptions)
-    expect(ast.static).toBe(false)
-    expect(ast.children[0].static).toBe(false)
-  })
-
-  it('key', () => {
-    const ast = parse('<p key="foo">hello world</p>', baseOptions)
-    optimize(ast, baseOptions)
-    expect(ast.static).toBe(false)
-    expect(ast.children[0].static).toBe(true)
-  })
-
-  it('ref', () => {
-    const ast = parse('<p ref="foo">hello world</p>', baseOptions)
-    optimize(ast, baseOptions)
-    expect(ast.static).toBe(false)
-    expect(ast.children[0].static).toBe(true)
-  })
-
-  it('transition', () => {
-    const ast = parse('<p v-if="show" transition="expand">hello world</p>', baseOptions)
-    optimize(ast, baseOptions)
-    expect(ast.static).toBe(false)
-    expect(ast.children[0].static).toBe(true)
-  })
-
-  it('v-bind directive', () => {
-    const ast = parse('<input type="text" name="field1" :value="msg">', baseOptions)
-    optimize(ast, baseOptions)
-    expect(ast.static).toBe(false)
-  })
-
-  it('v-on directive', () => {
-    const ast = parse('<input type="text" name="field1" :value="msg" @input="onInput">', baseOptions)
-    optimize(ast, baseOptions)
-    expect(ast.static).toBe(false)
-  })
-
-  it('custom directive', () => {
-    const ast = parse('<form><input type="text" name="field1" :value="msg" v-validate:field1="required"></form>', baseOptions)
-    optimize(ast, baseOptions)
-    expect(ast.static).toBe(false)
-    expect(ast.children[0].static).toBe(false)
-  })
-
-  it('not root ast', () => {
-    const ast = null
-    optimize(ast, baseOptions)
-    expect(ast).toBe(null)
-  })
-
-  it('not specified isReservedTag option', () => {
-    const ast = parse('<h1 id="section1">hello world</h1>', baseOptions)
-    optimize(ast, {})
-    expect(ast.static).toBe(false)
-  })
-
-  it('mark static trees inside v-for', () => {
-    const ast = parse(`<div><div v-for="i in 10"><p><span>hi</span></p></div></div>`, baseOptions)
-    optimize(ast, baseOptions)
-    expect(ast.children[0].children[0].staticRoot).toBe(true)
-    expect(ast.children[0].children[0].staticInFor).toBe(true)
-  })
-
-  it('mark static trees inside v-for with nested v-else and v-once', () => {
-    const ast = parse(`
-      <div v-if="1"></div>
-      <div v-else-if="2">
-        <div v-for="i in 10" :key="i">
-          <div v-if="1">{{ i }}</div>
-          <div v-else-if="2" v-once>{{ i }}</div>
-          <div v-else v-once>{{ i }}</div>
-        </div>
-      </div>
-      <div v-else>
-        <div v-for="i in 10" :key="i">
-          <div v-if="1">{{ i }}</div>
-          <div v-else v-once>{{ i }}</div>
-        </div>
-      </div>
-      `, baseOptions)
-    optimize(ast, baseOptions)
-    expect(ast.ifConditions[1].block.children[0].children[0].ifConditions[1].block.staticRoot).toBe(false)
-    expect(ast.ifConditions[1].block.children[0].children[0].ifConditions[1].block.staticInFor).toBe(true)
-
-    expect(ast.ifConditions[1].block.children[0].children[0].ifConditions[2].block.staticRoot).toBe(false)
-    expect(ast.ifConditions[1].block.children[0].children[0].ifConditions[2].block.staticInFor).toBe(true)
-
-    expect(ast.ifConditions[2].block.children[0].children[0].ifConditions[1].block.staticRoot).toBe(false)
-    expect(ast.ifConditions[2].block.children[0].children[0].ifConditions[1].block.staticInFor).toBe(true)
-  })
-})
diff --git a/1.Vue/test/unit/modules/compiler/parser.spec.js b/1.Vue/test/unit/modules/compiler/parser.spec.js
deleted file mode 100644
index d6521bb..0000000
--- a/1.Vue/test/unit/modules/compiler/parser.spec.js
+++ /dev/null
@@ -1,884 +0,0 @@
-import { parse } from 'compiler/parser/index'
-import { extend } from 'shared/util'
-import { baseOptions } from 'web/compiler/options'
-import { isIE, isEdge } from 'core/util/env'
-
-describe('parser', () => {
-  it('simple element', () => {
-    const ast = parse('<h1>hello world</h1>', baseOptions)
-    expect(ast.tag).toBe('h1')
-    expect(ast.plain).toBe(true)
-    expect(ast.children[0].text).toBe('hello world')
-  })
-
-  it('interpolation in element', () => {
-    const ast = parse('<h1>{{msg}}</h1>', baseOptions)
-    expect(ast.tag).toBe('h1')
-    expect(ast.plain).toBe(true)
-    expect(ast.children[0].expression).toBe('_s(msg)')
-  })
-
-  it('child elements', () => {
-    const ast = parse('<ul><li>hello world</li></ul>', baseOptions)
-    expect(ast.tag).toBe('ul')
-    expect(ast.plain).toBe(true)
-    expect(ast.children[0].tag).toBe('li')
-    expect(ast.children[0].plain).toBe(true)
-    expect(ast.children[0].children[0].text).toBe('hello world')
-    expect(ast.children[0].parent).toBe(ast)
-  })
-
-  it('unary element', () => {
-    const ast = parse('<hr>', baseOptions)
-    expect(ast.tag).toBe('hr')
-    expect(ast.plain).toBe(true)
-    expect(ast.children.length).toBe(0)
-  })
-
-  it('svg element', () => {
-    const ast = parse('<svg><text>hello world</text></svg>', baseOptions)
-    expect(ast.tag).toBe('svg')
-    expect(ast.ns).toBe('svg')
-    expect(ast.plain).toBe(true)
-    expect(ast.children[0].tag).toBe('text')
-    expect(ast.children[0].children[0].text).toBe('hello world')
-    expect(ast.children[0].parent).toBe(ast)
-  })
-
-  it('camelCase element', () => {
-    const ast = parse('<MyComponent><p>hello world</p></MyComponent>', baseOptions)
-    expect(ast.tag).toBe('MyComponent')
-    expect(ast.plain).toBe(true)
-    expect(ast.children[0].tag).toBe('p')
-    expect(ast.children[0].plain).toBe(true)
-    expect(ast.children[0].children[0].text).toBe('hello world')
-    expect(ast.children[0].parent).toBe(ast)
-  })
-
-  it('forbidden element', () => {
-    // style
-    const styleAst = parse('<style>error { color: red; }</style>', baseOptions)
-    expect(styleAst.tag).toBe('style')
-    expect(styleAst.plain).toBe(true)
-    expect(styleAst.forbidden).toBe(true)
-    expect(styleAst.children[0].text).toBe('error { color: red; }')
-    expect('Templates should only be responsible for mapping the state').toHaveBeenWarned()
-    // script
-    const scriptAst = parse('<script type="text/javascript">alert("hello world!")</script>', baseOptions)
-    expect(scriptAst.tag).toBe('script')
-    expect(scriptAst.plain).toBe(false)
-    expect(scriptAst.forbidden).toBe(true)
-    expect(scriptAst.children[0].text).toBe('alert("hello world!")')
-    expect('Templates should only be responsible for mapping the state').toHaveBeenWarned()
-  })
-
-  it('not contain root element', () => {
-    parse('hello world', baseOptions)
-    expect('Component template requires a root element, rather than just text').toHaveBeenWarned()
-  })
-
-  it('warn text before root element', () => {
-    parse('before root {{ interpolation }}<div></div>', baseOptions)
-    expect('text "before root {{ interpolation }}" outside root element will be ignored.').toHaveBeenWarned()
-  })
-
-  it('warn text after root element', () => {
-    parse('<div></div>after root {{ interpolation }}', baseOptions)
-    expect('text "after root {{ interpolation }}" outside root element will be ignored.').toHaveBeenWarned()
-  })
-
-  it('warn multiple root elements', () => {
-    parse('<div></div><div></div>', baseOptions)
-    expect('Component template should contain exactly one root element').toHaveBeenWarned()
-  })
-
-  it('remove duplicate whitespace text nodes caused by comments', () => {
-    const ast = parse(`<div><a></a> <!----> <a></a></div>`, baseOptions)
-    expect(ast.children.length).toBe(3)
-    expect(ast.children[0].tag).toBe('a')
-    expect(ast.children[1].text).toBe(' ')
-    expect(ast.children[2].tag).toBe('a')
-  })
-
-  it('remove text nodes between v-if conditions', () => {
-    const ast = parse(`<div><div v-if="1"></div> <div v-else-if="2"></div> <div v-else></div> <span></span></div>`, baseOptions)
-    expect(ast.children.length).toBe(3)
-    expect(ast.children[0].tag).toBe('div')
-    expect(ast.children[0].ifConditions.length).toBe(3)
-    expect(ast.children[1].text).toBe(' ') // text
-    expect(ast.children[2].tag).toBe('span')
-  })
-
-  it('warn non whitespace text between v-if conditions', () => {
-    parse(`<div><div v-if="1"></div> foo <div v-else></div></div>`, baseOptions)
-    expect(`text "foo" between v-if and v-else(-if) will be ignored`).toHaveBeenWarned()
-  })
-
-  it('not warn 2 root elements with v-if and v-else', () => {
-    parse('<div v-if="1"></div><div v-else></div>', baseOptions)
-    expect('Component template should contain exactly one root element')
-      .not.toHaveBeenWarned()
-  })
-
-  it('not warn 3 root elements with v-if, v-else-if and v-else', () => {
-    parse('<div v-if="1"></div><div v-else-if="2"></div><div v-else></div>', baseOptions)
-    expect('Component template should contain exactly one root element')
-      .not.toHaveBeenWarned()
-  })
-
-  it('not warn 2 root elements with v-if and v-else on separate lines', () => {
-    parse(`
-      <div v-if="1"></div>
-      <div v-else></div>
-    `, baseOptions)
-    expect('Component template should contain exactly one root element')
-      .not.toHaveBeenWarned()
-  })
-
-  it('not warn 3 or more root elements with v-if, v-else-if and v-else on separate lines', () => {
-    parse(`
-      <div v-if="1"></div>
-      <div v-else-if="2"></div>
-      <div v-else></div>
-    `, baseOptions)
-    expect('Component template should contain exactly one root element')
-      .not.toHaveBeenWarned()
-
-    parse(`
-      <div v-if="1"></div>
-      <div v-else-if="2"></div>
-      <div v-else-if="3"></div>
-      <div v-else-if="4"></div>
-      <div v-else></div>
-    `, baseOptions)
-    expect('Component template should contain exactly one root element')
-      .not.toHaveBeenWarned()
-  })
-
-  it('generate correct ast for 2 root elements with v-if and v-else on separate lines', () => {
-    const ast = parse(`
-      <div v-if="1"></div>
-      <p v-else></p>
-    `, baseOptions)
-    expect(ast.tag).toBe('div')
-    expect(ast.ifConditions[1].block.tag).toBe('p')
-  })
-
-  it('generate correct ast for 3 or more root elements with v-if and v-else on separate lines', () => {
-    const ast = parse(`
-      <div v-if="1"></div>
-      <span v-else-if="2"></span>
-      <p v-else></p>
-    `, baseOptions)
-    expect(ast.tag).toBe('div')
-    expect(ast.ifConditions[0].block.tag).toBe('div')
-    expect(ast.ifConditions[1].block.tag).toBe('span')
-    expect(ast.ifConditions[2].block.tag).toBe('p')
-
-    const astMore = parse(`
-      <div v-if="1"></div>
-      <span v-else-if="2"></span>
-      <div v-else-if="3"></div>
-      <span v-else-if="4"></span>
-      <p v-else></p>
-    `, baseOptions)
-    expect(astMore.tag).toBe('div')
-    expect(astMore.ifConditions[0].block.tag).toBe('div')
-    expect(astMore.ifConditions[1].block.tag).toBe('span')
-    expect(astMore.ifConditions[2].block.tag).toBe('div')
-    expect(astMore.ifConditions[3].block.tag).toBe('span')
-    expect(astMore.ifConditions[4].block.tag).toBe('p')
-  })
-
-  it('warn 2 root elements with v-if', () => {
-    parse('<div v-if="1"></div><div v-if="2"></div>', baseOptions)
-    expect('Component template should contain exactly one root element').toHaveBeenWarned()
-  })
-
-  it('warn 3 root elements with v-if and v-else on first 2', () => {
-    parse('<div v-if="1"></div><div v-else></div><div></div>', baseOptions)
-    expect('Component template should contain exactly one root element').toHaveBeenWarned()
-  })
-
-  it('warn 3 root elements with v-if and v-else-if on first 2', () => {
-    parse('<div v-if="1"></div><div v-else-if></div><div></div>', baseOptions)
-    expect('Component template should contain exactly one root element').toHaveBeenWarned()
-  })
-
-  it('warn 4 root elements with v-if, v-else-if and v-else on first 2', () => {
-    parse('<div v-if="1"></div><div v-else-if></div><div v-else></div><div></div>', baseOptions)
-    expect('Component template should contain exactly one root element').toHaveBeenWarned()
-  })
-
-  it('warn 2 root elements with v-if and v-else with v-for on 2nd', () => {
-    parse('<div v-if="1"></div><div v-else v-for="i in [1]"></div>', baseOptions)
-    expect('Cannot use v-for on stateful component root element because it renders multiple elements')
-      .toHaveBeenWarned()
-  })
-
-  it('warn 2 root elements with v-if and v-else-if with v-for on 2nd', () => {
-    parse('<div v-if="1"></div><div v-else-if="2" v-for="i in [1]"></div>', baseOptions)
-    expect('Cannot use v-for on stateful component root element because it renders multiple elements')
-      .toHaveBeenWarned()
-  })
-
-  it('warn <template> as root element', () => {
-    parse('<template></template>', baseOptions)
-    expect('Cannot use <template> as component root element').toHaveBeenWarned()
-  })
-
-  it('warn <slot> as root element', () => {
-    parse('<slot></slot>', baseOptions)
-    expect('Cannot use <slot> as component root element').toHaveBeenWarned()
-  })
-
-  it('warn v-for on root element', () => {
-    parse('<div v-for="item in items"></div>', baseOptions)
-    expect('Cannot use v-for on stateful component root element').toHaveBeenWarned()
-  })
-
-  it('warn <template> key', () => {
-    parse('<div><template v-for="i in 10" :key="i"></template></div>', baseOptions)
-    expect('<template> cannot be keyed').toHaveBeenWarned()
-  })
-
-  it('warn the child of the <transition-group> component has sequential index', () => {
-    parse(`
-      <div>
-        <transition-group>
-          <i v-for="(o, i) of arr" :key="i"></i>
-        </transition-group>
-      </div>
-    `, baseOptions)
-    expect('Do not use v-for index as key on <transition-group> children').toHaveBeenWarned()
-  })
-
-  it('v-pre directive', () => {
-    const ast = parse('<div v-pre id="message1"><p>{{msg}}</p></div>', baseOptions)
-    expect(ast.pre).toBe(true)
-    expect(ast.attrs[0].name).toBe('id')
-    expect(ast.attrs[0].value).toBe('"message1"')
-    expect(ast.children[0].children[0].text).toBe('{{msg}}')
-  })
-
-  it('v-pre directive should leave template in DOM', () => {
-    const ast = parse('<div v-pre id="message1"><template id="template1"><p>{{msg}}</p></template></div>', baseOptions)
-    expect(ast.pre).toBe(true)
-    expect(ast.attrs[0].name).toBe('id')
-    expect(ast.attrs[0].value).toBe('"message1"')
-    expect(ast.children[0].attrs[0].name).toBe('id')
-    expect(ast.children[0].attrs[0].value).toBe('"template1"')
-  })
-
-  it('v-for directive basic syntax', () => {
-    const ast = parse('<ul><li v-for="item in items"></li></ul>', baseOptions)
-    const liAst = ast.children[0]
-    expect(liAst.for).toBe('items')
-    expect(liAst.alias).toBe('item')
-  })
-
-  it('v-for directive iteration syntax', () => {
-    const ast = parse('<ul><li v-for="(item, index) in items"></li></ul>', baseOptions)
-    const liAst = ast.children[0]
-    expect(liAst.for).toBe('items')
-    expect(liAst.alias).toBe('item')
-    expect(liAst.iterator1).toBe('index')
-    expect(liAst.iterator2).toBeUndefined()
-  })
-
-  it('v-for directive iteration syntax (multiple)', () => {
-    const ast = parse('<ul><li v-for="(item, key, index) in items"></li></ul>', baseOptions)
-    const liAst = ast.children[0]
-    expect(liAst.for).toBe('items')
-    expect(liAst.alias).toBe('item')
-    expect(liAst.iterator1).toBe('key')
-    expect(liAst.iterator2).toBe('index')
-  })
-
-  it('v-for directive key', () => {
-    const ast = parse('<ul><li v-for="item in items" :key="item.uid"></li></ul>', baseOptions)
-    const liAst = ast.children[0]
-    expect(liAst.for).toBe('items')
-    expect(liAst.alias).toBe('item')
-    expect(liAst.key).toBe('item.uid')
-  })
-
-  it('v-for directive destructuring', () => {
-    let ast = parse('<ul><li v-for="{ foo } in items"></li></ul>', baseOptions)
-    let liAst = ast.children[0]
-    expect(liAst.for).toBe('items')
-    expect(liAst.alias).toBe('{ foo }')
-
-    // with paren
-    ast = parse('<ul><li v-for="({ foo }) in items"></li></ul>', baseOptions)
-    liAst = ast.children[0]
-    expect(liAst.for).toBe('items')
-    expect(liAst.alias).toBe('{ foo }')
-
-    // multi-var destructuring
-    ast = parse('<ul><li v-for="{ foo, bar, baz } in items"></li></ul>', baseOptions)
-    liAst = ast.children[0]
-    expect(liAst.for).toBe('items')
-    expect(liAst.alias).toBe('{ foo, bar, baz }')
-
-    // multi-var destructuring with paren
-    ast = parse('<ul><li v-for="({ foo, bar, baz }) in items"></li></ul>', baseOptions)
-    liAst = ast.children[0]
-    expect(liAst.for).toBe('items')
-    expect(liAst.alias).toBe('{ foo, bar, baz }')
-
-    // with index
-    ast = parse('<ul><li v-for="({ foo }, i) in items"></li></ul>', baseOptions)
-    liAst = ast.children[0]
-    expect(liAst.for).toBe('items')
-    expect(liAst.alias).toBe('{ foo }')
-    expect(liAst.iterator1).toBe('i')
-
-    // with key + index
-    ast = parse('<ul><li v-for="({ foo }, i, j) in items"></li></ul>', baseOptions)
-    liAst = ast.children[0]
-    expect(liAst.for).toBe('items')
-    expect(liAst.alias).toBe('{ foo }')
-    expect(liAst.iterator1).toBe('i')
-    expect(liAst.iterator2).toBe('j')
-
-    // multi-var destructuring with index
-    ast = parse('<ul><li v-for="({ foo, bar, baz }, i) in items"></li></ul>', baseOptions)
-    liAst = ast.children[0]
-    expect(liAst.for).toBe('items')
-    expect(liAst.alias).toBe('{ foo, bar, baz }')
-    expect(liAst.iterator1).toBe('i')
-
-    // array
-    ast = parse('<ul><li v-for="[ foo ] in items"></li></ul>', baseOptions)
-    liAst = ast.children[0]
-    expect(liAst.for).toBe('items')
-    expect(liAst.alias).toBe('[ foo ]')
-
-    // multi-array
-    ast = parse('<ul><li v-for="[ foo, bar, baz ] in items"></li></ul>', baseOptions)
-    liAst = ast.children[0]
-    expect(liAst.for).toBe('items')
-    expect(liAst.alias).toBe('[ foo, bar, baz ]')
-
-    // array with paren
-    ast = parse('<ul><li v-for="([ foo ]) in items"></li></ul>', baseOptions)
-    liAst = ast.children[0]
-    expect(liAst.for).toBe('items')
-    expect(liAst.alias).toBe('[ foo ]')
-
-    // multi-array with paren
-    ast = parse('<ul><li v-for="([ foo, bar, baz ]) in items"></li></ul>', baseOptions)
-    liAst = ast.children[0]
-    expect(liAst.for).toBe('items')
-    expect(liAst.alias).toBe('[ foo, bar, baz ]')
-
-    // array with index
-    ast = parse('<ul><li v-for="([ foo ], i) in items"></li></ul>', baseOptions)
-    liAst = ast.children[0]
-    expect(liAst.for).toBe('items')
-    expect(liAst.alias).toBe('[ foo ]')
-    expect(liAst.iterator1).toBe('i')
-
-    // array with key + index
-    ast = parse('<ul><li v-for="([ foo ], i, j) in items"></li></ul>', baseOptions)
-    liAst = ast.children[0]
-    expect(liAst.for).toBe('items')
-    expect(liAst.alias).toBe('[ foo ]')
-    expect(liAst.iterator1).toBe('i')
-    expect(liAst.iterator2).toBe('j')
-
-    // multi-array with paren
-    ast = parse('<ul><li v-for="([ foo, bar, baz ]) in items"></li></ul>', baseOptions)
-    liAst = ast.children[0]
-    expect(liAst.for).toBe('items')
-    expect(liAst.alias).toBe('[ foo, bar, baz ]')
-
-    // multi-array with index
-    ast = parse('<ul><li v-for="([ foo, bar, baz ], i) in items"></li></ul>', baseOptions)
-    liAst = ast.children[0]
-    expect(liAst.for).toBe('items')
-    expect(liAst.alias).toBe('[ foo, bar, baz ]')
-    expect(liAst.iterator1).toBe('i')
-
-    // nested
-    ast = parse('<ul><li v-for="({ foo, bar: { baz }, qux: [ n ] }, i, j) in items"></li></ul>', baseOptions)
-    liAst = ast.children[0]
-    expect(liAst.for).toBe('items')
-    expect(liAst.alias).toBe('{ foo, bar: { baz }, qux: [ n ] }')
-    expect(liAst.iterator1).toBe('i')
-    expect(liAst.iterator2).toBe('j')
-
-    // array nested
-    ast = parse('<ul><li v-for="([ foo, { bar }, baz ], i, j) in items"></li></ul>', baseOptions)
-    liAst = ast.children[0]
-    expect(liAst.for).toBe('items')
-    expect(liAst.alias).toBe('[ foo, { bar }, baz ]')
-    expect(liAst.iterator1).toBe('i')
-    expect(liAst.iterator2).toBe('j')
-  })
-
-  it('v-for directive invalid syntax', () => {
-    parse('<ul><li v-for="item into items"></li></ul>', baseOptions)
-    expect('Invalid v-for expression').toHaveBeenWarned()
-  })
-
-  it('v-if directive syntax', () => {
-    const ast = parse('<p v-if="show">hello world</p>', baseOptions)
-    expect(ast.if).toBe('show')
-    expect(ast.ifConditions[0].exp).toBe('show')
-  })
-
-  it('v-else-if directive syntax', () => {
-    const ast = parse('<div><p v-if="show">hello</p><span v-else-if="2">elseif</span><p v-else>world</p></div>', baseOptions)
-    const ifAst = ast.children[0]
-    const conditionsAst = ifAst.ifConditions
-    expect(conditionsAst.length).toBe(3)
-    expect(conditionsAst[1].block.children[0].text).toBe('elseif')
-    expect(conditionsAst[1].block.parent).toBe(ast)
-    expect(conditionsAst[2].block.children[0].text).toBe('world')
-    expect(conditionsAst[2].block.parent).toBe(ast)
-  })
-
-  it('v-else directive syntax', () => {
-    const ast = parse('<div><p v-if="show">hello</p><p v-else>world</p></div>', baseOptions)
-    const ifAst = ast.children[0]
-    const conditionsAst = ifAst.ifConditions
-    expect(conditionsAst.length).toBe(2)
-    expect(conditionsAst[1].block.children[0].text).toBe('world')
-    expect(conditionsAst[1].block.parent).toBe(ast)
-  })
-
-  it('v-else-if directive invalid syntax', () => {
-    parse('<div><p v-else-if="1">world</p></div>', baseOptions)
-    expect('v-else-if="1" used on element').toHaveBeenWarned()
-  })
-
-  it('v-else directive invalid syntax', () => {
-    parse('<div><p v-else>world</p></div>', baseOptions)
-    expect('v-else used on element').toHaveBeenWarned()
-  })
-
-  it('v-once directive syntax', () => {
-    const ast = parse('<p v-once>world</p>', baseOptions)
-    expect(ast.once).toBe(true)
-  })
-
-  it('slot tag single syntax', () => {
-    const ast = parse('<div><slot></slot></div>', baseOptions)
-    expect(ast.children[0].tag).toBe('slot')
-    expect(ast.children[0].slotName).toBeUndefined()
-  })
-
-  it('slot tag named syntax', () => {
-    const ast = parse('<div><slot name="one">hello world</slot></div>', baseOptions)
-    expect(ast.children[0].tag).toBe('slot')
-    expect(ast.children[0].slotName).toBe('"one"')
-  })
-
-  it('slot target', () => {
-    const ast = parse('<p slot="one">hello world</p>', baseOptions)
-    expect(ast.slotTarget).toBe('"one"')
-  })
-
-  it('component properties', () => {
-    const ast = parse('<my-component :msg="hello"></my-component>', baseOptions)
-    expect(ast.attrs[0].name).toBe('msg')
-    expect(ast.attrs[0].value).toBe('hello')
-  })
-
-  it('component "is" attribute', () => {
-    const ast = parse('<my-component is="component1"></my-component>', baseOptions)
-    expect(ast.component).toBe('"component1"')
-  })
-
-  it('component "inline-template" attribute', () => {
-    const ast = parse('<my-component inline-template>hello world</my-component>', baseOptions)
-    expect(ast.inlineTemplate).toBe(true)
-  })
-
-  it('class binding', () => {
-    // static
-    const ast1 = parse('<p class="class1">hello world</p>', baseOptions)
-    expect(ast1.staticClass).toBe('"class1"')
-    // dynamic
-    const ast2 = parse('<p :class="class1">hello world</p>', baseOptions)
-    expect(ast2.classBinding).toBe('class1')
-    // interpolation warning
-    parse('<p class="{{error}}">hello world</p>', baseOptions)
-    expect('Interpolation inside attributes has been removed').toHaveBeenWarned()
-  })
-
-  it('style binding', () => {
-    const ast = parse('<p :style="error">hello world</p>', baseOptions)
-    expect(ast.styleBinding).toBe('error')
-  })
-
-  it('attribute with v-bind', () => {
-    const ast = parse('<input type="text" name="field1" :value="msg">', baseOptions)
-    expect(ast.attrsList[0].name).toBe('type')
-    expect(ast.attrsList[0].value).toBe('text')
-    expect(ast.attrsList[1].name).toBe('name')
-    expect(ast.attrsList[1].value).toBe('field1')
-    expect(ast.attrsMap['type']).toBe('text')
-    expect(ast.attrsMap['name']).toBe('field1')
-    expect(ast.attrs[0].name).toBe('type')
-    expect(ast.attrs[0].value).toBe('"text"')
-    expect(ast.attrs[1].name).toBe('name')
-    expect(ast.attrs[1].value).toBe('"field1"')
-    expect(ast.props[0].name).toBe('value')
-    expect(ast.props[0].value).toBe('msg')
-  })
-
-  it('empty v-bind expression', () => {
-    parse('<div :empty-msg=""></div>', baseOptions)
-    expect('The value for a v-bind expression cannot be empty. Found in "v-bind:empty-msg"').toHaveBeenWarned()
-  })
-
-  if (process.env.VBIND_PROP_SHORTHAND) {
-    it('v-bind.prop shorthand syntax', () => {
-      const ast = parse('<div .id="foo"></div>', baseOptions)
-      expect(ast.props).toEqual([{ name: 'id', value: 'foo', dynamic: false }])
-    })
-
-    it('v-bind.prop shorthand syntax w/ modifiers', () => {
-      const ast = parse('<div .id.mod="foo"></div>', baseOptions)
-      expect(ast.props).toEqual([{ name: 'id', value: 'foo', dynamic: false }])
-    })
-
-    it('v-bind.prop shorthand dynamic argument', () => {
-      const ast = parse('<div .[id]="foo"></div>', baseOptions)
-      expect(ast.props).toEqual([{ name: 'id', value: 'foo', dynamic: true }])
-    })
-  }
-
-  // This only works for string templates.
-  // In-DOM templates will be malformed before Vue can parse it.
-  describe('parse and warn invalid dynamic arguments', () => {
-    [
-      `<div v-bind:['foo' + bar]="baz"/>`,
-      `<div :['foo' + bar]="baz"/>`,
-      `<div @['foo' + bar]="baz"/>`,
-      `<foo #['foo' + bar]="baz"/>`,
-      `<div :['foo' + bar].some.mod="baz"/>`
-    ].forEach(template => {
-      it(template, () => {
-        const ast = parse(template, baseOptions)
-        expect(`Invalid dynamic argument expression`).toHaveBeenWarned()
-      })
-    })
-  })
-
-  // #6887
-  it('special case static attribute that must be props', () => {
-    const ast = parse('<video muted></video>', baseOptions)
-    expect(ast.attrs[0].name).toBe('muted')
-    expect(ast.attrs[0].value).toBe('""')
-    expect(ast.props[0].name).toBe('muted')
-    expect(ast.props[0].value).toBe('true')
-  })
-
-  it('attribute with v-on', () => {
-    const ast = parse('<input type="text" name="field1" :value="msg" @input="onInput">', baseOptions)
-    expect(ast.events.input.value).toBe('onInput')
-  })
-
-  it('attribute with directive', () => {
-    const ast = parse('<input type="text" name="field1" :value="msg" v-validate:field1="required">', baseOptions)
-    expect(ast.directives[0].name).toBe('validate')
-    expect(ast.directives[0].value).toBe('required')
-    expect(ast.directives[0].arg).toBe('field1')
-  })
-
-  it('attribute with modifiered directive', () => {
-    const ast = parse('<input type="text" name="field1" :value="msg" v-validate.on.off>', baseOptions)
-    expect(ast.directives[0].modifiers.on).toBe(true)
-    expect(ast.directives[0].modifiers.off).toBe(true)
-  })
-
-  it('literal attribute', () => {
-    // basic
-    const ast1 = parse('<input type="text" name="field1" value="hello world">', baseOptions)
-    expect(ast1.attrsList[0].name).toBe('type')
-    expect(ast1.attrsList[0].value).toBe('text')
-    expect(ast1.attrsList[1].name).toBe('name')
-    expect(ast1.attrsList[1].value).toBe('field1')
-    expect(ast1.attrsList[2].name).toBe('value')
-    expect(ast1.attrsList[2].value).toBe('hello world')
-    expect(ast1.attrsMap['type']).toBe('text')
-    expect(ast1.attrsMap['name']).toBe('field1')
-    expect(ast1.attrsMap['value']).toBe('hello world')
-    expect(ast1.attrs[0].name).toBe('type')
-    expect(ast1.attrs[0].value).toBe('"text"')
-    expect(ast1.attrs[1].name).toBe('name')
-    expect(ast1.attrs[1].value).toBe('"field1"')
-    expect(ast1.attrs[2].name).toBe('value')
-    expect(ast1.attrs[2].value).toBe('"hello world"')
-    // interpolation warning
-    parse('<input type="text" name="field1" value="{{msg}}">', baseOptions)
-    expect('Interpolation inside attributes has been removed').toHaveBeenWarned()
-  })
-
-  if (!isIE && !isEdge) {
-    it('duplicate attribute', () => {
-      parse('<p class="class1" class="class1">hello world</p>', baseOptions)
-      expect('duplicate attribute').toHaveBeenWarned()
-    })
-  }
-
-  it('custom delimiter', () => {
-    const ast = parse('<p>{msg}</p>', extend({ delimiters: ['{', '}'] }, baseOptions))
-    expect(ast.children[0].expression).toBe('_s(msg)')
-  })
-
-  it('not specified getTagNamespace option', () => {
-    const options = extend({}, baseOptions)
-    delete options.getTagNamespace
-    const ast = parse('<svg><text>hello world</text></svg>', options)
-    expect(ast.tag).toBe('svg')
-    expect(ast.ns).toBeUndefined()
-  })
-
-  it('not specified mustUseProp', () => {
-    const options = extend({}, baseOptions)
-    delete options.mustUseProp
-    const ast = parse('<input type="text" name="field1" :value="msg">', options)
-    expect(ast.props).toBeUndefined()
-  })
-
-  it('use prop when prop modifier was explicitly declared', () => {
-    const ast = parse('<component is="textarea" :value.prop="val" />', baseOptions)
-    expect(ast.attrs).toBeUndefined()
-    expect(ast.props.length).toBe(1)
-    expect(ast.props[0].name).toBe('value')
-    expect(ast.props[0].value).toBe('val')
-  })
-
-  it('pre/post transforms', () => {
-    const options = extend({}, baseOptions)
-    const spy1 = jasmine.createSpy('preTransform')
-    const spy2 = jasmine.createSpy('postTransform')
-    options.modules = options.modules.concat([{
-      preTransformNode (el) {
-        spy1(el.tag)
-      },
-      postTransformNode (el) {
-        expect(el.attrs.length).toBe(1)
-        spy2(el.tag)
-      }
-    }])
-    parse('<img v-pre src="hi">', options)
-    expect(spy1).toHaveBeenCalledWith('img')
-    expect(spy2).toHaveBeenCalledWith('img')
-  })
-
-  it('preserve whitespace in <pre> tag', function () {
-    const options = extend({}, baseOptions)
-    const ast = parse('<pre><code>  \n<span>hi</span>\n  </code><span> </span></pre>', options)
-    const code = ast.children[0]
-    expect(code.children[0].type).toBe(3)
-    expect(code.children[0].text).toBe('  \n')
-    expect(code.children[2].type).toBe(3)
-    expect(code.children[2].text).toBe('\n  ')
-
-    const span = ast.children[1]
-    expect(span.children[0].type).toBe(3)
-    expect(span.children[0].text).toBe(' ')
-  })
-
-  // #5992
-  it('ignore the first newline in <pre> tag', function () {
-    const options = extend({}, baseOptions)
-    const ast = parse('<div><pre>\nabc</pre>\ndef<pre>\n\nabc</pre></div>', options)
-    const pre = ast.children[0]
-    expect(pre.children[0].type).toBe(3)
-    expect(pre.children[0].text).toBe('abc')
-    const text = ast.children[1]
-    expect(text.type).toBe(3)
-    expect(text.text).toBe('\ndef')
-    const pre2 = ast.children[2]
-    expect(pre2.children[0].type).toBe(3)
-    expect(pre2.children[0].text).toBe('\nabc')
-  })
-
-  it('keep first newline after unary tag in <pre>', () => {
-    const options = extend({}, baseOptions)
-    const ast = parse('<pre>abc<input>\ndef</pre>', options)
-    expect(ast.children[1].type).toBe(1)
-    expect(ast.children[1].tag).toBe('input')
-    expect(ast.children[2].type).toBe(3)
-    expect(ast.children[2].text).toBe('\ndef')
-  })
-
-  it('forgivingly handle < in plain text', () => {
-    const options = extend({}, baseOptions)
-    const ast = parse('<p>1 < 2 < 3</p>', options)
-    expect(ast.tag).toBe('p')
-    expect(ast.children.length).toBe(1)
-    expect(ast.children[0].type).toBe(3)
-    expect(ast.children[0].text).toBe('1 < 2 < 3')
-  })
-
-  it('IE conditional comments', () => {
-    const options = extend({}, baseOptions)
-    const ast = parse(`
-      <div>
-        <!--[if lte IE 8]>
-          <p>Test 1</p>
-        <![endif]-->
-      </div>
-    `, options)
-    expect(ast.tag).toBe('div')
-    expect(ast.children.length).toBe(0)
-  })
-
-  it('parse content in textarea as text', () => {
-    const options = extend({}, baseOptions)
-
-    const whitespace = parse(`
-      <textarea>
-        <p>Test 1</p>
-        test2
-      </textarea>
-    `, options)
-    expect(whitespace.tag).toBe('textarea')
-    expect(whitespace.children.length).toBe(1)
-    expect(whitespace.children[0].type).toBe(3)
-    // textarea is whitespace sensitive
-    expect(whitespace.children[0].text).toBe(`        <p>Test 1</p>
-        test2
-      `)
-
-    const comment = parse('<textarea><!--comment--></textarea>', options)
-    expect(comment.tag).toBe('textarea')
-    expect(comment.children.length).toBe(1)
-    expect(comment.children[0].type).toBe(3)
-    expect(comment.children[0].text).toBe('<!--comment-->')
-  })
-
-  // #5526
-  it('should not decode text in script tags', () => {
-    const options = extend({}, baseOptions)
-    const ast = parse(`<script type="x/template">&gt;<foo>&lt;</script>`, options)
-    expect(ast.children[0].text).toBe(`&gt;<foo>&lt;`)
-  })
-
-  it('should ignore comments', () => {
-    const options = extend({}, baseOptions)
-    const ast = parse(`<div>123<!--comment here--></div>`, options)
-    expect(ast.tag).toBe('div')
-    expect(ast.children.length).toBe(1)
-    expect(ast.children[0].type).toBe(3)
-    expect(ast.children[0].text).toBe('123')
-  })
-
-  it('should kept comments', () => {
-    const options = extend({
-      comments: true
-    }, baseOptions)
-    const ast = parse(`<div>123<!--comment here--></div>`, options)
-    expect(ast.tag).toBe('div')
-    expect(ast.children.length).toBe(2)
-    expect(ast.children[0].type).toBe(3)
-    expect(ast.children[0].text).toBe('123')
-    expect(ast.children[1].type).toBe(3) // parse comment with ASTText
-    expect(ast.children[1].isComment).toBe(true) // parse comment with ASTText
-    expect(ast.children[1].text).toBe('comment here')
-  })
-
-  // #9407
-  it('should parse templates with comments anywhere', () => {
-    const options = extend({
-      comments: true
-    }, baseOptions)
-    const ast = parse(`<!--comment here--><div>123</div>`, options)
-    expect(ast.tag).toBe('div')
-    expect(ast.children.length).toBe(1)
-  })
-
-  // #8103
-  it('should allow CRLFs in string interpolations', () => {
-    const ast = parse(`<p>{{\r\nmsg\r\n}}</p>`, baseOptions)
-    expect(ast.children[0].expression).toBe('_s(msg)')
-  })
-
-  it('preserveWhitespace: false', () => {
-    const options = extend({
-      preserveWhitespace: false
-    }, baseOptions)
-
-    const ast = parse('<p>\n  Welcome to <b>Vue.js</b>    <i>world</i>  \n  <span>.\n  Have fun!\n</span></p>', options)
-    expect(ast.tag).toBe('p')
-    expect(ast.children.length).toBe(4)
-    expect(ast.children[0].type).toBe(3)
-    expect(ast.children[0].text).toBe('\n  Welcome to ')
-    expect(ast.children[1].tag).toBe('b')
-    expect(ast.children[1].children[0].text).toBe('Vue.js')
-    expect(ast.children[2].tag).toBe('i')
-    expect(ast.children[2].children[0].text).toBe('world')
-    expect(ast.children[3].tag).toBe('span')
-    expect(ast.children[3].children[0].text).toBe('.\n  Have fun!\n')
-  })
-
-  const condenseOptions = extend({
-    whitespace: 'condense',
-    // should be ignored when whitespace is specified
-    preserveWhitespace: false
-  }, baseOptions)
-
-  it(`whitespace: 'condense'`, () => {
-    const options = extend({}, condenseOptions)
-    const ast = parse('<p>\n  Welcome to <b>Vue.js</b>    <i>world</i>  \n  <span>.\n  Have fun!\n</span></p>', options)
-    expect(ast.tag).toBe('p')
-    expect(ast.children.length).toBe(5)
-    expect(ast.children[0].type).toBe(3)
-    expect(ast.children[0].text).toBe(' Welcome to ')
-    expect(ast.children[1].tag).toBe('b')
-    expect(ast.children[1].children[0].text).toBe('Vue.js')
-    expect(ast.children[2].type).toBe(3)
-    // should condense inline whitespace into single space
-    expect(ast.children[2].text).toBe(' ')
-    expect(ast.children[3].tag).toBe('i')
-    expect(ast.children[3].children[0].text).toBe('world')
-    // should have removed the whitespace node between tags that contains newlines
-    expect(ast.children[4].tag).toBe('span')
-    expect(ast.children[4].children[0].text).toBe('. Have fun! ')
-  })
-
-  it(`preserve whitespace in <pre> tag with whitespace: 'condense'`, function () {
-    const options = extend({}, condenseOptions)
-    const ast = parse('<pre><code>  \n<span>hi</span>\n  </code><span> </span></pre>', options)
-    const code = ast.children[0]
-    expect(code.children[0].type).toBe(3)
-    expect(code.children[0].text).toBe('  \n')
-    expect(code.children[2].type).toBe(3)
-    expect(code.children[2].text).toBe('\n  ')
-
-    const span = ast.children[1]
-    expect(span.children[0].type).toBe(3)
-    expect(span.children[0].text).toBe(' ')
-  })
-
-  it(`ignore the first newline in <pre> tag with whitespace: 'condense'`, function () {
-    const options = extend({}, condenseOptions)
-    const ast = parse('<div><pre>\nabc</pre>\ndef<pre>\n\nabc</pre></div>', options)
-    const pre = ast.children[0]
-    expect(pre.children[0].type).toBe(3)
-    expect(pre.children[0].text).toBe('abc')
-    const text = ast.children[1]
-    expect(text.type).toBe(3)
-    expect(text.text).toBe(' def')
-    const pre2 = ast.children[2]
-    expect(pre2.children[0].type).toBe(3)
-    expect(pre2.children[0].text).toBe('\nabc')
-  })
-
-  it(`keep first newline after unary tag in <pre> with whitespace: 'condense'`, () => {
-    const options = extend({}, condenseOptions)
-    const ast = parse('<pre>abc<input>\ndef</pre>', options)
-    expect(ast.children[1].type).toBe(1)
-    expect(ast.children[1].tag).toBe('input')
-    expect(ast.children[2].type).toBe(3)
-    expect(ast.children[2].text).toBe('\ndef')
-  })
-})
diff --git a/1.Vue/test/unit/modules/observer/dep.spec.js b/1.Vue/test/unit/modules/observer/dep.spec.js
deleted file mode 100644
index 02809f8..0000000
--- a/1.Vue/test/unit/modules/observer/dep.spec.js
+++ /dev/null
@@ -1,63 +0,0 @@
-import Dep from 'core/observer/dep'
-
-describe('Dep', () => {
-  let dep
-
-  beforeEach(() => {
-    dep = new Dep()
-  })
-
-  describe('instance', () => {
-    it('should be created with correct properties', () => {
-      expect(dep.subs.length).toBe(0)
-      expect(new Dep().id).toBe(dep.id + 1)
-    })
-  })
-
-  describe('addSub()', () => {
-    it('should add sub', () => {
-      dep.addSub(null)
-      expect(dep.subs.length).toBe(1)
-      expect(dep.subs[0]).toBe(null)
-    })
-  })
-
-  describe('removeSub()', () => {
-    it('should remove sub', () => {
-      dep.subs.push(null)
-      dep.removeSub(null)
-      expect(dep.subs.length).toBe(0)
-    })
-  })
-
-  describe('depend()', () => {
-    let _target
-
-    beforeAll(() => {
-      _target = Dep.target
-    })
-
-    afterAll(() => {
-      Dep.target = _target
-    })
-
-    it('should do nothing if no target', () => {
-      Dep.target = null
-      dep.depend()
-    })
-
-    it('should add itself to target', () => {
-      Dep.target = jasmine.createSpyObj('TARGET', ['addDep'])
-      dep.depend()
-      expect(Dep.target.addDep).toHaveBeenCalledWith(dep)
-    })
-  })
-
-  describe('notify()', () => {
-    it('should notify subs', () => {
-      dep.subs.push(jasmine.createSpyObj('SUB', ['update']))
-      dep.notify()
-      expect(dep.subs[0].update).toHaveBeenCalled()
-    })
-  })
-})
diff --git a/1.Vue/test/unit/modules/observer/observer.spec.js b/1.Vue/test/unit/modules/observer/observer.spec.js
deleted file mode 100644
index 5a8d47c..0000000
--- a/1.Vue/test/unit/modules/observer/observer.spec.js
+++ /dev/null
@@ -1,372 +0,0 @@
-import Vue from 'vue'
-import {
-  Observer,
-  observe,
-  set as setProp,
-  del as delProp
-} from 'core/observer/index'
-import Dep from 'core/observer/dep'
-import { hasOwn } from 'core/util/index'
-
-describe('Observer', () => {
-  it('create on non-observables', () => {
-    // skip primitive value
-    const ob1 = observe(1)
-    expect(ob1).toBeUndefined()
-    // avoid vue instance
-    const ob2 = observe(new Vue())
-    expect(ob2).toBeUndefined()
-    // avoid frozen objects
-    const ob3 = observe(Object.freeze({}))
-    expect(ob3).toBeUndefined()
-  })
-
-  it('create on object', () => {
-    // on object
-    const obj = {
-      a: {},
-      b: {}
-    }
-    const ob1 = observe(obj)
-    expect(ob1 instanceof Observer).toBe(true)
-    expect(ob1.value).toBe(obj)
-    expect(obj.__ob__).toBe(ob1)
-    // should've walked children
-    expect(obj.a.__ob__ instanceof Observer).toBe(true)
-    expect(obj.b.__ob__ instanceof Observer).toBe(true)
-    // should return existing ob on already observed objects
-    const ob2 = observe(obj)
-    expect(ob2).toBe(ob1)
-  })
-
-  it('create on null', () => {
-    // on null
-    const obj = Object.create(null)
-    obj.a = {}
-    obj.b = {}
-    const ob1 = observe(obj)
-    expect(ob1 instanceof Observer).toBe(true)
-    expect(ob1.value).toBe(obj)
-    expect(obj.__ob__).toBe(ob1)
-    // should've walked children
-    expect(obj.a.__ob__ instanceof Observer).toBe(true)
-    expect(obj.b.__ob__ instanceof Observer).toBe(true)
-    // should return existing ob on already observed objects
-    const ob2 = observe(obj)
-    expect(ob2).toBe(ob1)
-  })
-
-  it('create on already observed object', () => {
-    // on object
-    const obj = {}
-    let val = 0
-    let getCount = 0
-    Object.defineProperty(obj, 'a', {
-      configurable: true,
-      enumerable: true,
-      get () {
-        getCount++
-        return val
-      },
-      set (v) { val = v }
-    })
-
-    const ob1 = observe(obj)
-    expect(ob1 instanceof Observer).toBe(true)
-    expect(ob1.value).toBe(obj)
-    expect(obj.__ob__).toBe(ob1)
-
-    getCount = 0
-    // Each read of 'a' should result in only one get underlying get call
-    obj.a
-    expect(getCount).toBe(1)
-    obj.a
-    expect(getCount).toBe(2)
-
-    // should return existing ob on already observed objects
-    const ob2 = observe(obj)
-    expect(ob2).toBe(ob1)
-
-    // should call underlying setter
-    obj.a = 10
-    expect(val).toBe(10)
-  })
-
-  it('create on property with only getter', () => {
-    // on object
-    const obj = {}
-    Object.defineProperty(obj, 'a', {
-      configurable: true,
-      enumerable: true,
-      get () { return 123 }
-    })
-
-    const ob1 = observe(obj)
-    expect(ob1 instanceof Observer).toBe(true)
-    expect(ob1.value).toBe(obj)
-    expect(obj.__ob__).toBe(ob1)
-
-    // should be able to read
-    expect(obj.a).toBe(123)
-
-    // should return existing ob on already observed objects
-    const ob2 = observe(obj)
-    expect(ob2).toBe(ob1)
-
-    // since there is no setter, you shouldn't be able to write to it
-    // PhantomJS throws when a property with no setter is set
-    // but other real browsers don't
-    try {
-      obj.a = 101
-    } catch (e) {}
-    expect(obj.a).toBe(123)
-  })
-
-  it('create on property with only setter', () => {
-    // on object
-    const obj = {}
-    let val = 10
-    Object.defineProperty(obj, 'a', { // eslint-disable-line accessor-pairs
-      configurable: true,
-      enumerable: true,
-      set (v) { val = v }
-    })
-
-    const ob1 = observe(obj)
-    expect(ob1 instanceof Observer).toBe(true)
-    expect(ob1.value).toBe(obj)
-    expect(obj.__ob__).toBe(ob1)
-
-    // reads should return undefined
-    expect(obj.a).toBe(undefined)
-
-    // should return existing ob on already observed objects
-    const ob2 = observe(obj)
-    expect(ob2).toBe(ob1)
-
-    // writes should call the set function
-    obj.a = 100
-    expect(val).toBe(100)
-  })
-
-  it('create on property which is marked not configurable', () => {
-    // on object
-    const obj = {}
-    Object.defineProperty(obj, 'a', {
-      configurable: false,
-      enumerable: true,
-      val: 10
-    })
-
-    const ob1 = observe(obj)
-    expect(ob1 instanceof Observer).toBe(true)
-    expect(ob1.value).toBe(obj)
-    expect(obj.__ob__).toBe(ob1)
-  })
-
-  it('create on array', () => {
-    // on object
-    const arr = [{}, {}]
-    const ob1 = observe(arr)
-    expect(ob1 instanceof Observer).toBe(true)
-    expect(ob1.value).toBe(arr)
-    expect(arr.__ob__).toBe(ob1)
-    // should've walked children
-    expect(arr[0].__ob__ instanceof Observer).toBe(true)
-    expect(arr[1].__ob__ instanceof Observer).toBe(true)
-  })
-
-  it('observing object prop change', () => {
-    const obj = { a: { b: 2 }, c: NaN }
-    observe(obj)
-    // mock a watcher!
-    const watcher = {
-      deps: [],
-      addDep (dep) {
-        this.deps.push(dep)
-        dep.addSub(this)
-      },
-      update: jasmine.createSpy()
-    }
-    // collect dep
-    Dep.target = watcher
-    obj.a.b
-    Dep.target = null
-    expect(watcher.deps.length).toBe(3) // obj.a + a + a.b
-    obj.a.b = 3
-    expect(watcher.update.calls.count()).toBe(1)
-    // swap object
-    obj.a = { b: 4 }
-    expect(watcher.update.calls.count()).toBe(2)
-    watcher.deps = []
-
-    Dep.target = watcher
-    obj.a.b
-    obj.c
-    Dep.target = null
-    expect(watcher.deps.length).toBe(4)
-    // set on the swapped object
-    obj.a.b = 5
-    expect(watcher.update.calls.count()).toBe(3)
-    // should not trigger on NaN -> NaN set
-    obj.c = NaN
-    expect(watcher.update.calls.count()).toBe(3)
-  })
-
-  it('observing object prop change on defined property', () => {
-    const obj = { val: 2 }
-    Object.defineProperty(obj, 'a', {
-      configurable: true,
-      enumerable: true,
-      get () { return this.val },
-      set (v) {
-        this.val = v
-        return this.val
-      }
-    })
-
-    observe(obj)
-    expect(obj.a).toBe(2) // Make sure 'this' is preserved
-    obj.a = 3
-    expect(obj.val).toBe(3) // make sure 'setter' was called
-    obj.val = 5
-    expect(obj.a).toBe(5) // make sure 'getter' was called
-  })
-
-  it('observing set/delete', () => {
-    const obj1 = { a: 1 }
-    const ob1 = observe(obj1)
-    const dep1 = ob1.dep
-    spyOn(dep1, 'notify')
-    setProp(obj1, 'b', 2)
-    expect(obj1.b).toBe(2)
-    expect(dep1.notify.calls.count()).toBe(1)
-    delProp(obj1, 'a')
-    expect(hasOwn(obj1, 'a')).toBe(false)
-    expect(dep1.notify.calls.count()).toBe(2)
-    // set existing key, should be a plain set and not
-    // trigger own ob's notify
-    setProp(obj1, 'b', 3)
-    expect(obj1.b).toBe(3)
-    expect(dep1.notify.calls.count()).toBe(2)
-    // set non-existing key
-    setProp(obj1, 'c', 1)
-    expect(obj1.c).toBe(1)
-    expect(dep1.notify.calls.count()).toBe(3)
-    // should ignore deleting non-existing key
-    delProp(obj1, 'a')
-    expect(dep1.notify.calls.count()).toBe(3)
-    // should work on non-observed objects
-    const obj2 = { a: 1 }
-    delProp(obj2, 'a')
-    expect(hasOwn(obj2, 'a')).toBe(false)
-    // should work on Object.create(null)
-    const obj3 = Object.create(null)
-    obj3.a = 1
-    const ob3 = observe(obj3)
-    const dep3 = ob3.dep
-    spyOn(dep3, 'notify')
-    setProp(obj3, 'b', 2)
-    expect(obj3.b).toBe(2)
-    expect(dep3.notify.calls.count()).toBe(1)
-    delProp(obj3, 'a')
-    expect(hasOwn(obj3, 'a')).toBe(false)
-    expect(dep3.notify.calls.count()).toBe(2)
-    // set and delete non-numeric key on array
-    const arr2 = ['a']
-    const ob2 = observe(arr2)
-    const dep2 = ob2.dep
-    spyOn(dep2, 'notify')
-    setProp(arr2, 'b', 2)
-    expect(arr2.b).toBe(2)
-    expect(dep2.notify.calls.count()).toBe(1)
-    delProp(arr2, 'b')
-    expect(hasOwn(arr2, 'b')).toBe(false)
-    expect(dep2.notify.calls.count()).toBe(2)
-  })
-
-  it('warning set/delete on a Vue instance', done => {
-    const vm = new Vue({
-      template: '<div>{{a}}</div>',
-      data: { a: 1 }
-    }).$mount()
-    expect(vm.$el.outerHTML).toBe('<div>1</div>')
-    Vue.set(vm, 'a', 2)
-    waitForUpdate(() => {
-      expect(vm.$el.outerHTML).toBe('<div>2</div>')
-      expect('Avoid adding reactive properties to a Vue instance').not.toHaveBeenWarned()
-      Vue.delete(vm, 'a')
-    }).then(() => {
-      expect('Avoid deleting properties on a Vue instance').toHaveBeenWarned()
-      expect(vm.$el.outerHTML).toBe('<div>2</div>')
-      Vue.set(vm, 'b', 123)
-      expect('Avoid adding reactive properties to a Vue instance').toHaveBeenWarned()
-    }).then(done)
-  })
-
-  it('warning set/delete on Vue instance root $data', done => {
-    const data = { a: 1 }
-    const vm = new Vue({
-      template: '<div>{{a}}</div>',
-      data
-    }).$mount()
-    expect(vm.$el.outerHTML).toBe('<div>1</div>')
-    expect(Vue.set(data, 'a', 2)).toBe(2)
-    waitForUpdate(() => {
-      expect(vm.$el.outerHTML).toBe('<div>2</div>')
-      expect('Avoid adding reactive properties to a Vue instance').not.toHaveBeenWarned()
-      Vue.delete(data, 'a')
-    }).then(() => {
-      expect('Avoid deleting properties on a Vue instance').toHaveBeenWarned()
-      expect(vm.$el.outerHTML).toBe('<div>2</div>')
-      expect(Vue.set(data, 'b', 123)).toBe(123)
-      expect('Avoid adding reactive properties to a Vue instance').toHaveBeenWarned()
-    }).then(done)
-  })
-
-  it('observing array mutation', () => {
-    const arr = []
-    const ob = observe(arr)
-    const dep = ob.dep
-    spyOn(dep, 'notify')
-    const objs = [{}, {}, {}]
-    arr.push(objs[0])
-    arr.pop()
-    arr.unshift(objs[1])
-    arr.shift()
-    arr.splice(0, 0, objs[2])
-    arr.sort()
-    arr.reverse()
-    expect(dep.notify.calls.count()).toBe(7)
-    // inserted elements should be observed
-    objs.forEach(obj => {
-      expect(obj.__ob__ instanceof Observer).toBe(true)
-    })
-  })
-
-  it('warn set/delete on non valid values', () => {
-    try {
-      setProp(null, 'foo', 1)
-    } catch (e) {}
-    expect(`Cannot set reactive property on undefined, null, or primitive value`).toHaveBeenWarned()
-
-    try {
-      delProp(null, 'foo')
-    } catch (e) {}
-    expect(`Cannot delete reactive property on undefined, null, or primitive value`).toHaveBeenWarned()
-  })
-
-  it('should lazy invoke existing getters', () => {
-    const obj = {}
-    let called = false
-    Object.defineProperty(obj, 'getterProp', {
-      enumerable: true,
-      get: () => {
-        called = true
-        return 'some value'
-      }
-    })
-    observe(obj)
-    expect(called).toBe(false)
-  })
-})
diff --git a/1.Vue/test/unit/modules/observer/scheduler.spec.js b/1.Vue/test/unit/modules/observer/scheduler.spec.js
deleted file mode 100644
index 1443375..0000000
--- a/1.Vue/test/unit/modules/observer/scheduler.spec.js
+++ /dev/null
@@ -1,180 +0,0 @@
-import Vue from 'vue'
-import {
-  MAX_UPDATE_COUNT,
-  queueWatcher as _queueWatcher
-} from 'core/observer/scheduler'
-
-function queueWatcher (watcher) {
-  watcher.vm = {} // mock vm
-  _queueWatcher(watcher)
-}
-
-describe('Scheduler', () => {
-  let spy
-  beforeEach(() => {
-    spy = jasmine.createSpy('scheduler')
-  })
-
-  it('queueWatcher', done => {
-    queueWatcher({
-      run: spy
-    })
-    waitForUpdate(() => {
-      expect(spy.calls.count()).toBe(1)
-    }).then(done)
-  })
-
-  it('dedup', done => {
-    queueWatcher({
-      id: 1,
-      run: spy
-    })
-    queueWatcher({
-      id: 1,
-      run: spy
-    })
-    waitForUpdate(() => {
-      expect(spy.calls.count()).toBe(1)
-    }).then(done)
-  })
-
-  it('allow duplicate when flushing', done => {
-    const job = {
-      id: 1,
-      run: spy
-    }
-    queueWatcher(job)
-    queueWatcher({
-      id: 2,
-      run () { queueWatcher(job) }
-    })
-    waitForUpdate(() => {
-      expect(spy.calls.count()).toBe(2)
-    }).then(done)
-  })
-
-  it('call user watchers before component re-render', done => {
-    const calls = []
-    const vm = new Vue({
-      data: {
-        a: 1
-      },
-      template: '<div>{{ a }}</div>',
-      watch: {
-        a () { calls.push(1) }
-      },
-      beforeUpdate () {
-        calls.push(2)
-      }
-    }).$mount()
-    vm.a = 2
-    waitForUpdate(() => {
-      expect(calls).toEqual([1, 2])
-    }).then(done)
-  })
-
-  it('call user watcher triggered by component re-render immediately', done => {
-    // this happens when a component re-render updates the props of a child
-    const calls = []
-    const vm = new Vue({
-      data: {
-        a: 1
-      },
-      watch: {
-        a () {
-          calls.push(1)
-        }
-      },
-      beforeUpdate () {
-        calls.push(2)
-      },
-      template: '<div><test :a="a"></test></div>',
-      components: {
-        test: {
-          props: ['a'],
-          template: '<div>{{ a }}</div>',
-          watch: {
-            a () {
-              calls.push(3)
-            }
-          },
-          beforeUpdate () {
-            calls.push(4)
-          }
-        }
-      }
-    }).$mount()
-    vm.a = 2
-    waitForUpdate(() => {
-      expect(calls).toEqual([1, 2, 3, 4])
-    }).then(done)
-  })
-
-  it('warn against infinite update loops', function (done) {
-    let count = 0
-    const job = {
-      id: 1,
-      run () {
-        count++
-        queueWatcher(job)
-      }
-    }
-    queueWatcher(job)
-    waitForUpdate(() => {
-      expect(count).toBe(MAX_UPDATE_COUNT + 1)
-      expect('infinite update loop').toHaveBeenWarned()
-    }).then(done)
-  })
-
-  it('should call newly pushed watcher after current watcher is done', done => {
-    const callOrder = []
-    queueWatcher({
-      id: 1,
-      user: true,
-      run () {
-        callOrder.push(1)
-        queueWatcher({
-          id: 2,
-          run () {
-            callOrder.push(3)
-          }
-        })
-        callOrder.push(2)
-      }
-    })
-    waitForUpdate(() => {
-      expect(callOrder).toEqual([1, 2, 3])
-    }).then(done)
-  })
-
-  // GitHub issue #5191
-  it('emit should work when updated hook called', done => {
-    const el = document.createElement('div')
-    const vm = new Vue({
-      template: `<div><child @change="bar" :foo="foo"></child></div>`,
-      data: {
-        foo: 0
-      },
-      methods: {
-        bar: spy
-      },
-      components: {
-        child: {
-          template: `<div>{{foo}}</div>`,
-          props: ['foo'],
-          updated () {
-            this.$emit('change')
-          }
-        }
-      }
-    }).$mount(el)
-    vm.$nextTick(() => {
-      vm.foo = 1
-      vm.$nextTick(() => {
-        expect(vm.$el.innerHTML).toBe('<div>1</div>')
-        expect(spy).toHaveBeenCalled()
-        done()
-      })
-    })
-  })
-})
diff --git a/1.Vue/test/unit/modules/observer/watcher.spec.js b/1.Vue/test/unit/modules/observer/watcher.spec.js
deleted file mode 100644
index 724a3cc..0000000
--- a/1.Vue/test/unit/modules/observer/watcher.spec.js
+++ /dev/null
@@ -1,181 +0,0 @@
-import Vue from 'vue'
-import Watcher from 'core/observer/watcher'
-
-describe('Watcher', () => {
-  let vm, spy
-  beforeEach(() => {
-    vm = new Vue({
-      template: '<div></div>',
-      data: {
-        a: 1,
-        b: {
-          c: 2,
-          d: 4
-        },
-        c: 'c',
-        msg: 'yo'
-      }
-    }).$mount()
-    spy = jasmine.createSpy('watcher')
-  })
-
-  it('path', done => {
-    const watcher = new Watcher(vm, 'b.c', spy)
-    expect(watcher.value).toBe(2)
-    vm.b.c = 3
-    waitForUpdate(() => {
-      expect(watcher.value).toBe(3)
-      expect(spy).toHaveBeenCalledWith(3, 2)
-      vm.b = { c: 4 } // swapping the object
-    }).then(() => {
-      expect(watcher.value).toBe(4)
-      expect(spy).toHaveBeenCalledWith(4, 3)
-    }).then(done)
-  })
-
-  it('non-existent path, set later', done => {
-    const watcher1 = new Watcher(vm, 'b.e', spy)
-    expect(watcher1.value).toBeUndefined()
-    // check $add should not affect isolated children
-    const child2 = new Vue({ parent: vm })
-    const watcher2 = new Watcher(child2, 'b.e', spy)
-    expect(watcher2.value).toBeUndefined()
-    Vue.set(vm.b, 'e', 123)
-    waitForUpdate(() => {
-      expect(watcher1.value).toBe(123)
-      expect(watcher2.value).toBeUndefined()
-      expect(spy.calls.count()).toBe(1)
-      expect(spy).toHaveBeenCalledWith(123, undefined)
-    }).then(done)
-  })
-
-  it('delete', done => {
-    const watcher = new Watcher(vm, 'b.c', spy)
-    expect(watcher.value).toBe(2)
-    Vue.delete(vm.b, 'c')
-    waitForUpdate(() => {
-      expect(watcher.value).toBeUndefined()
-      expect(spy).toHaveBeenCalledWith(undefined, 2)
-    }).then(done)
-  })
-
-  it('path containing $data', done => {
-    const watcher = new Watcher(vm, '$data.b.c', spy)
-    expect(watcher.value).toBe(2)
-    vm.b = { c: 3 }
-    waitForUpdate(() => {
-      expect(watcher.value).toBe(3)
-      expect(spy).toHaveBeenCalledWith(3, 2)
-      vm.$data.b.c = 4
-    }).then(() => {
-      expect(watcher.value).toBe(4)
-      expect(spy).toHaveBeenCalledWith(4, 3)
-    }).then(done)
-  })
-
-  it('deep watch', done => {
-    let oldB
-    new Watcher(vm, 'b', spy, {
-      deep: true
-    })
-    vm.b.c = { d: 4 }
-    waitForUpdate(() => {
-      expect(spy).toHaveBeenCalledWith(vm.b, vm.b)
-      oldB = vm.b
-      vm.b = { c: [{ a: 1 }] }
-    }).then(() => {
-      expect(spy).toHaveBeenCalledWith(vm.b, oldB)
-      expect(spy.calls.count()).toBe(2)
-      vm.b.c[0].a = 2
-    }).then(() => {
-      expect(spy).toHaveBeenCalledWith(vm.b, vm.b)
-      expect(spy.calls.count()).toBe(3)
-    }).then(done)
-  })
-
-  it('deep watch $data', done => {
-    new Watcher(vm, '$data', spy, {
-      deep: true
-    })
-    vm.b.c = 3
-    waitForUpdate(() => {
-      expect(spy).toHaveBeenCalledWith(vm.$data, vm.$data)
-    }).then(done)
-  })
-
-  it('deep watch with circular references', done => {
-    new Watcher(vm, 'b', spy, {
-      deep: true
-    })
-    Vue.set(vm.b, '_', vm.b)
-    waitForUpdate(() => {
-      expect(spy).toHaveBeenCalledWith(vm.b, vm.b)
-      expect(spy.calls.count()).toBe(1)
-      vm.b._.c = 1
-    }).then(() => {
-      expect(spy).toHaveBeenCalledWith(vm.b, vm.b)
-      expect(spy.calls.count()).toBe(2)
-    }).then(done)
-  })
-
-  it('fire change for prop addition/deletion in non-deep mode', done => {
-    new Watcher(vm, 'b', spy)
-    Vue.set(vm.b, 'e', 123)
-    waitForUpdate(() => {
-      expect(spy).toHaveBeenCalledWith(vm.b, vm.b)
-      expect(spy.calls.count()).toBe(1)
-      Vue.delete(vm.b, 'e')
-    }).then(() => {
-      expect(spy.calls.count()).toBe(2)
-    }).then(done)
-  })
-
-  it('watch function', done => {
-    const watcher = new Watcher(vm, function () {
-      return this.a + this.b.d
-    }, spy)
-    expect(watcher.value).toBe(5)
-    vm.a = 2
-    waitForUpdate(() => {
-      expect(spy).toHaveBeenCalledWith(6, 5)
-      vm.b = { d: 2 }
-    }).then(() => {
-      expect(spy).toHaveBeenCalledWith(4, 6)
-    }).then(done)
-  })
-
-  it('lazy mode', done => {
-    const watcher = new Watcher(vm, function () {
-      return this.a + this.b.d
-    }, null, { lazy: true })
-    expect(watcher.lazy).toBe(true)
-    expect(watcher.value).toBeUndefined()
-    expect(watcher.dirty).toBe(true)
-    watcher.evaluate()
-    expect(watcher.value).toBe(5)
-    expect(watcher.dirty).toBe(false)
-    vm.a = 2
-    waitForUpdate(() => {
-      expect(watcher.value).toBe(5)
-      expect(watcher.dirty).toBe(true)
-      watcher.evaluate()
-      expect(watcher.value).toBe(6)
-      expect(watcher.dirty).toBe(false)
-    }).then(done)
-  })
-
-  it('teardown', done => {
-    const watcher = new Watcher(vm, 'b.c', spy)
-    watcher.teardown()
-    vm.b.c = 3
-    waitForUpdate(() => {
-      expect(watcher.active).toBe(false)
-      expect(spy).not.toHaveBeenCalled()
-    }).then(done)
-  })
-
-  it('warn not support path', () => {
-    new Watcher(vm, 'd.e + c', spy)
-    expect('Failed watching path:').toHaveBeenWarned()
-  })
-})
diff --git a/1.Vue/test/unit/modules/server-compiler/compiler-options.spec.js b/1.Vue/test/unit/modules/server-compiler/compiler-options.spec.js
deleted file mode 100644
index aa151a8..0000000
--- a/1.Vue/test/unit/modules/server-compiler/compiler-options.spec.js
+++ /dev/null
@@ -1,13 +0,0 @@
-import { ssrCompile } from 'web/server/compiler'
-
-describe('ssrCompile options', () => {
-  it('comments', () => {
-    const compiled = ssrCompile(`
-      <div>
-        <!-- test comments -->
-      </div>
-    `, { comments: true })
-
-    expect(compiled.render).toContain('<!-- test comments -->')
-  })
-})
diff --git a/1.Vue/test/unit/modules/server-compiler/optimizer.spec.js b/1.Vue/test/unit/modules/server-compiler/optimizer.spec.js
deleted file mode 100644
index e69de29..0000000
diff --git a/1.Vue/test/unit/modules/sfc/sfc-parser.spec.js b/1.Vue/test/unit/modules/sfc/sfc-parser.spec.js
deleted file mode 100644
index 1072b7b..0000000
--- a/1.Vue/test/unit/modules/sfc/sfc-parser.spec.js
+++ /dev/null
@@ -1,211 +0,0 @@
-import { parseComponent } from 'sfc/parser'
-
-describe('Single File Component parser', () => {
-  it('should parse', () => {
-    const res = parseComponent(`
-      <template>
-        <div>hi</div>
-      </template>
-      <style src="./test.css"></style>
-      <style lang="stylus" scoped>
-        h1
-          color red
-        h2
-          color green
-      </style>
-      <style module>
-        h1 { font-weight: bold }
-      </style>
-      <style bool-attr val-attr="test"></style>
-      <script>
-        export default {}
-      </script>
-      <div>
-        <style>nested should be ignored</style>
-      </div>
-    `)
-    expect(res.template.content.trim()).toBe('<div>hi</div>')
-    expect(res.styles.length).toBe(4)
-    expect(res.styles[0].src).toBe('./test.css')
-    expect(res.styles[1].lang).toBe('stylus')
-    expect(res.styles[1].scoped).toBe(true)
-    expect(res.styles[1].content.trim()).toBe('h1\n  color red\nh2\n  color green')
-    expect(res.styles[2].module).toBe(true)
-    expect(res.styles[3].attrs['bool-attr']).toBe(true)
-    expect(res.styles[3].attrs['val-attr']).toBe('test')
-    expect(res.script.content.trim()).toBe('export default {}')
-  })
-
-  it('should parse template with closed input', () => {
-    const res = parseComponent(`
-      <template>
-        <input type="text"/>
-      </template>
-    `)
-
-    expect(res.template.content.trim()).toBe('<input type="text"/>')
-  })
-
-  it('should handle nested template', () => {
-    const res = parseComponent(`
-      <template>
-        <div><template v-if="ok">hi</template></div>
-      </template>
-    `)
-    expect(res.template.content.trim()).toBe('<div><template v-if="ok">hi</template></div>')
-  })
-
-  it('deindent content', () => {
-    const content = `
-      <template>
-        <div></div>
-      </template>
-      <script>
-        export default {}
-      </script>
-      <style>
-        h1 { color: red }
-      </style>
-    `
-    const deindentDefault = parseComponent(content.trim(), { pad: false })
-    const deindentEnabled = parseComponent(content.trim(), { pad: false, deindent: true })
-    const deindentDisabled = parseComponent(content.trim(), { pad: false, deindent: false })
-
-    expect(deindentDefault.template.content).toBe('\n<div></div>\n')
-    expect(deindentDefault.script.content).toBe('\nexport default {}\n')
-    expect(deindentDefault.styles[0].content).toBe('\nh1 { color: red }\n')
-    expect(deindentEnabled.template.content).toBe('\n<div></div>\n')
-    expect(deindentEnabled.script.content).toBe('\nexport default {}\n')
-    expect(deindentEnabled.styles[0].content).toBe('\nh1 { color: red }\n')
-    expect(deindentDisabled.template.content).toBe('\n        <div></div>\n      ')
-    expect(deindentDisabled.script.content).toBe('\n        export default {}\n      ')
-    expect(deindentDisabled.styles[0].content).toBe('\n        h1 { color: red }\n      ')
-  })
-
-  it('pad content', () => {
-    const content = `
-      <template>
-        <div></div>
-      </template>
-      <script>
-        export default {}
-      </script>
-      <style>
-        h1 { color: red }
-      </style>
-`
-    const padDefault = parseComponent(content.trim(), { pad: true })
-    const padLine = parseComponent(content.trim(), { pad: 'line' })
-    const padSpace = parseComponent(content.trim(), { pad: 'space' })
-
-    expect(padDefault.script.content).toBe(Array(3 + 1).join('//\n') + '\nexport default {}\n')
-    expect(padDefault.styles[0].content).toBe(Array(6 + 1).join('\n') + '\nh1 { color: red }\n')
-    expect(padLine.script.content).toBe(Array(3 + 1).join('//\n') + '\nexport default {}\n')
-    expect(padLine.styles[0].content).toBe(Array(6 + 1).join('\n') + '\nh1 { color: red }\n')
-    expect(padSpace.script.content).toBe(`<template>
-        <div></div>
-      </template>
-      <script>`.replace(/./g, ' ') + '\nexport default {}\n')
-    expect(padSpace.styles[0].content).toBe(`<template>
-        <div></div>
-      </template>
-      <script>
-        export default {}
-      </script>
-      <style>`.replace(/./g, ' ') + '\nh1 { color: red }\n')
-  })
-
-  it('should handle template blocks with lang as special text', () => {
-    const res = parseComponent(`
-      <template lang="pug">
-        div
-          h1(v-if='1 < 2') hello
-      </template>
-    `)
-    expect(res.template.content.trim()).toBe(`div\n  h1(v-if='1 < 2') hello`)
-  })
-
-  it('should handle component contains "<" only', () => {
-    const res = parseComponent(`
-      <template>
-        <span><</span>
-      </template>
-    `)
-    expect(res.template.content.trim()).toBe(`<span><</span>`)
-  })
-
-  it('should handle custom blocks without parsing them', () => {
-    const res = parseComponent(`
-      <template>
-        <div></div>
-      </template>
-      <example name="simple">
-        <my-button ref="button">Hello</my-button>
-      </example>
-      <example name="with props">
-        <my-button color="red">Hello</my-button>
-      </example>
-      <test name="simple" foo="bar">
-      export default function simple (vm) {
-        describe('Hello', () => {
-          it('should display Hello', () => {
-            this.vm.$refs.button.$el.innerText.should.equal('Hello')
-          }))
-        }))
-      }
-      </test>
-    `)
-    expect(res.customBlocks.length).toBe(3)
-
-    const simpleExample = res.customBlocks[0]
-    expect(simpleExample.type).toBe('example')
-    expect(simpleExample.content.trim()).toBe('<my-button ref="button">Hello</my-button>')
-    expect(simpleExample.attrs.name).toBe('simple')
-
-    const withProps = res.customBlocks[1]
-    expect(withProps.type).toBe('example')
-    expect(withProps.content.trim()).toBe('<my-button color="red">Hello</my-button>')
-    expect(withProps.attrs.name).toBe('with props')
-
-    const simpleTest = res.customBlocks[2]
-    expect(simpleTest.type).toBe('test')
-    expect(simpleTest.content.trim()).toBe(`export default function simple (vm) {
-  describe('Hello', () => {
-    it('should display Hello', () => {
-      this.vm.$refs.button.$el.innerText.should.equal('Hello')
-    }))
-  }))
-}`)
-    expect(simpleTest.attrs.name).toBe('simple')
-    expect(simpleTest.attrs.foo).toBe('bar')
-  })
-
-  // Regression #4289
-  it('accepts nested template tag', () => {
-    const raw = `<div>
-      <template v-if="true === true">
-        <section class="section">
-          <div class="container">
-            Should be shown
-          </div>
-        </section>
-      </template>
-      <template v-else>
-        <p>Should not be shown</p>
-      </template>
-    </div>`
-    const res = parseComponent(`<template>${raw}</template>`)
-    expect(res.template.content.trim()).toBe(raw)
-  })
-
-  it('should not hang on trailing text', () => {
-    const res = parseComponent(`<template>hi</`)
-    expect(res.template.content).toBe('hi')
-  })
-
-  it('should collect errors with source range', () => {
-    const res = parseComponent(`<template>hi</`, { outputSourceRange: true })
-    expect(res.errors.length).toBe(1)
-    expect(res.errors[0].start).toBe(0)
-  })
-})
diff --git a/1.Vue/test/unit/modules/util/error.spec.js b/1.Vue/test/unit/modules/util/error.spec.js
deleted file mode 100644
index c9152bb..0000000
--- a/1.Vue/test/unit/modules/util/error.spec.js
+++ /dev/null
@@ -1,24 +0,0 @@
-import Vue from 'vue'
-import { invokeWithErrorHandling } from 'core/util/error'
-
-describe('invokeWithErrorHandling', () => {
-  if (typeof Promise !== 'undefined') {
-    it('should errorHandler call once when nested calls return rejected promise', done => {
-      const originalHandler = Vue.config.errorHandler
-      const handler = Vue.config.errorHandler = jasmine.createSpy()
-      const userCatch = jasmine.createSpy()
-      const err = new Error('fake error')
-
-      invokeWithErrorHandling(() => {
-        return invokeWithErrorHandling(() => {
-          return Promise.reject(err)
-        })
-      }).catch(userCatch).then(() => {
-        Vue.config.errorHandler = originalHandler
-        expect(handler.calls.count()).toBe(1)
-        expect(userCatch).toHaveBeenCalledWith(err)
-        done()
-      })
-    })
-  }
-})
diff --git a/1.Vue/test/unit/modules/util/next-tick.spec.js b/1.Vue/test/unit/modules/util/next-tick.spec.js
deleted file mode 100644
index 53f6124..0000000
--- a/1.Vue/test/unit/modules/util/next-tick.spec.js
+++ /dev/null
@@ -1,34 +0,0 @@
-import { nextTick } from 'core/util/next-tick'
-
-describe('nextTick', () => {
-  it('accepts a callback', done => {
-    nextTick(done)
-  })
-
-  it('returns undefined when passed a callback', () => {
-    expect(nextTick(() => {})).toBeUndefined()
-  })
-
-  if (typeof Promise !== 'undefined') {
-    it('returns a Promise when provided no callback', done => {
-      nextTick().then(done)
-    })
-
-    it('returns a Promise with a context argument when provided a falsy callback and an object', done => {
-      const obj = {}
-      nextTick(undefined, obj).then(ctx => {
-        expect(ctx).toBe(obj)
-        done()
-      })
-    })
-
-    it('returned Promise should resolve correctly vs callback', done => {
-      const spy = jasmine.createSpy()
-      nextTick(spy)
-      nextTick().then(() => {
-        expect(spy).toHaveBeenCalled()
-        done()
-      })
-    })
-  }
-})
diff --git a/1.Vue/test/unit/modules/vdom/create-component.spec.js b/1.Vue/test/unit/modules/vdom/create-component.spec.js
deleted file mode 100644
index 37f8226..0000000
--- a/1.Vue/test/unit/modules/vdom/create-component.spec.js
+++ /dev/null
@@ -1,153 +0,0 @@
-import Vue from 'vue'
-import { createComponent } from 'core/vdom/create-component'
-import { setCurrentRenderingInstance } from 'core/instance/render'
-
-describe('create-component', () => {
-  let vm
-  beforeEach(done => {
-    vm = new Vue({
-      template: '<p>{{msg}}</p>',
-      data () {
-        return { msg: 'hello, my children' }
-      }
-    }).$mount()
-    Vue.nextTick(done)
-  })
-
-  it('create a component basically', () => {
-    const child = {
-      name: 'child',
-      props: ['msg'],
-      render () {}
-    }
-    const data = {
-      props: { msg: 'hello world' },
-      attrs: { id: 1 },
-      staticAttrs: { class: 'foo' },
-      on: { notify: 'onNotify' }
-    }
-    const vnode = createComponent(child, data, vm, vm)
-    expect(vnode.tag).toMatch(/vue-component-[0-9]+-child/)
-    expect(vnode.data.attrs).toEqual({ id: 1 })
-    expect(vnode.data.staticAttrs).toEqual({ class: 'foo' })
-    expect(vnode.componentOptions.propsData).toEqual({ msg: 'hello world' })
-    expect(vnode.componentOptions.listeners).toEqual({ notify: 'onNotify' })
-    expect(vnode.children).toBeUndefined()
-    expect(vnode.text).toBeUndefined()
-    expect(vnode.elm).toBeUndefined()
-    expect(vnode.ns).toBeUndefined()
-    expect(vnode.context).toEqual(vm)
-  })
-
-  it('create a component when resolved with async loading', done => {
-    let vnode = null
-    const data = {
-      props: {},
-      staticAttrs: { class: 'foo' }
-    }
-    spyOn(vm, '$forceUpdate')
-    function async (resolve, reject) {
-      setTimeout(() => {
-        resolve({
-          name: 'child',
-          props: ['msg']
-        })
-        Vue.nextTick(loaded)
-      }, 0)
-    }
-    function go () {
-      setCurrentRenderingInstance(vm)
-      vnode = createComponent(async, data, vm, vm)
-      setCurrentRenderingInstance(null)
-      expect(vnode.isComment).toBe(true) // not to be loaded yet.
-      expect(vnode.asyncFactory).toBe(async)
-      expect(vnode.asyncFactory.owners.length).toEqual(1)
-    }
-    function loaded () {
-      setCurrentRenderingInstance(vm)
-      vnode = createComponent(async, data, vm, vm)
-      setCurrentRenderingInstance(null)
-      expect(vnode.tag).toMatch(/vue-component-[0-9]+-child/)
-      expect(vnode.data.staticAttrs).toEqual({ class: 'foo' })
-      expect(vnode.children).toBeUndefined()
-      expect(vnode.text).toBeUndefined()
-      expect(vnode.elm).toBeUndefined()
-      expect(vnode.ns).toBeUndefined()
-      expect(vnode.context).toEqual(vm)
-      expect(vnode.asyncFactory.owners.length).toEqual(0)
-      expect(vm.$forceUpdate).toHaveBeenCalled()
-      done()
-    }
-    go()
-  })
-
-  it('create a component when resolved with synchronous async loading', done => {
-    const data = {
-      props: {},
-      staticAttrs: { class: 'bar' }
-    }
-    spyOn(vm, '$forceUpdate')
-    function async (resolve, reject) {
-      resolve({
-        name: 'child',
-        props: ['msg']
-      })
-    }
-    setCurrentRenderingInstance(vm)
-    const vnode = createComponent(async, data, vm, vm)
-    setCurrentRenderingInstance(null)
-    expect(vnode.asyncFactory).toBe(async)
-    expect(vnode.asyncFactory.owners.length).toEqual(0)
-    expect(vnode.tag).toMatch(/vue-component-[0-9]+-child/)
-    expect(vnode.data.staticAttrs).toEqual({ class: 'bar' })
-    expect(vnode.children).toBeUndefined()
-    expect(vnode.text).toBeUndefined()
-    expect(vnode.elm).toBeUndefined()
-    expect(vnode.ns).toBeUndefined()
-    expect(vnode.context).toEqual(vm)
-    expect(vm.$forceUpdate).not.toHaveBeenCalled()
-    done()
-  })
-
-  it('not create a component when rejected with async loading', done => {
-    let vnode = null
-    const data = {
-      props: { msg: 'hello world' },
-      attrs: { id: 1 }
-    }
-    const reason = 'failed!!'
-    function async (resolve, reject) {
-      setTimeout(() => {
-        reject(reason)
-        Vue.nextTick(failed)
-      }, 0)
-    }
-    function go () {
-      setCurrentRenderingInstance(vm)
-      vnode = createComponent(async, data, vm, vm)
-      setCurrentRenderingInstance(null)
-      expect(vnode.isComment).toBe(true) // not to be loaded yet.
-    }
-    function failed () {
-      setCurrentRenderingInstance(vm)
-      vnode = createComponent(async, data, vm, vm)
-      setCurrentRenderingInstance(null)
-      expect(vnode.isComment).toBe(true) // failed, still a comment node
-      expect(`Failed to resolve async component: ${async}\nReason: ${reason}`).toHaveBeenWarned()
-      done()
-    }
-    go()
-  })
-
-  it('not create a component when specified with falsy', () => {
-    const vnode = createComponent(null, {}, vm, vm)
-    expect(vnode).toBeUndefined()
-  })
-
-  it('warn component definition type', () => {
-    const Ctor = 'child'
-    const vnode = createComponent(Ctor, {}, vm, vm)
-    expect(vnode).toBeUndefined()
-    expect(`Invalid Component definition: ${Ctor}`).toHaveBeenWarned()
-  })
-})
diff --git a/1.Vue/test/unit/modules/vdom/create-element.spec.js b/1.Vue/test/unit/modules/vdom/create-element.spec.js
deleted file mode 100644
index 6877385..0000000
--- a/1.Vue/test/unit/modules/vdom/create-element.spec.js
+++ /dev/null
@@ -1,276 +0,0 @@
-import Vue from 'vue'
-import { createEmptyVNode } from 'core/vdom/vnode'
-
-describe('create-element', () => {
-  it('render vnode with basic reserved tag using createElement', () => {
-    const vm = new Vue({
-      data: { msg: 'hello world' }
-    })
-    const h = vm.$createElement
-    const vnode = h('p', {})
-    expect(vnode.tag).toBe('p')
-    expect(vnode.data).toEqual({})
-    expect(vnode.children).toBeUndefined()
-    expect(vnode.text).toBeUndefined()
-    expect(vnode.elm).toBeUndefined()
-    expect(vnode.ns).toBeUndefined()
-    expect(vnode.context).toEqual(vm)
-  })
-
-  it('render vnode with component using createElement', () => {
-    const vm = new Vue({
-      data: { message: 'hello world' },
-      components: {
-        'my-component': {
-          props: ['msg']
-        }
-      }
-    })
-    const h = vm.$createElement
-    const vnode = h('my-component', { props: { msg: vm.message }})
-    expect(vnode.tag).toMatch(/vue-component-[0-9]+/)
-    expect(vnode.componentOptions.propsData).toEqual({ msg: vm.message })
-    expect(vnode.children).toBeUndefined()
-    expect(vnode.text).toBeUndefined()
-    expect(vnode.elm).toBeUndefined()
-    expect(vnode.ns).toBeUndefined()
-    expect(vnode.context).toEqual(vm)
-  })
-
-  it('render vnode with custom tag using createElement', () => {
-    const vm = new Vue({
-      data: { msg: 'hello world' }
-    })
-    const h = vm.$createElement
-    const tag = 'custom-tag'
-    const vnode = h(tag, {})
-    expect(vnode.tag).toBe('custom-tag')
-    expect(vnode.data).toEqual({})
-    expect(vnode.children).toBeUndefined()
-    expect(vnode.text).toBeUndefined()
-    expect(vnode.elm).toBeUndefined()
-    expect(vnode.ns).toBeUndefined()
-    expect(vnode.context).toEqual(vm)
-    expect(vnode.componentOptions).toBeUndefined()
-  })
-
-  it('render empty vnode with falsy tag using createElement', () => {
-    const vm = new Vue({
-      data: { msg: 'hello world' }
-    })
-    const h = vm.$createElement
-    const vnode = h(null, {})
-    expect(vnode).toEqual(createEmptyVNode())
-  })
-
-  it('render vnode with not string tag using createElement', () => {
-    const vm = new Vue({
-      data: { msg: 'hello world' }
-    })
-    const h = vm.$createElement
-    const vnode = h(Vue.extend({ // Component class
-      props: ['msg']
-    }), { props: { msg: vm.message }})
-    expect(vnode.tag).toMatch(/vue-component-[0-9]+/)
-    expect(vnode.componentOptions.propsData).toEqual({ msg: vm.message })
-    expect(vnode.children).toBeUndefined()
-    expect(vnode.text).toBeUndefined()
-    expect(vnode.elm).toBeUndefined()
-    expect(vnode.ns).toBeUndefined()
-    expect(vnode.context).toEqual(vm)
-  })
-
-  it('render vnode with createElement with children', () => {
-    const vm = new Vue({})
-    const h = vm.$createElement
-    const vnode = h('p', void 0, [h('br'), 'hello world', h('br')])
-    expect(vnode.children[0].tag).toBe('br')
-    expect(vnode.children[1].text).toBe('hello world')
-    expect(vnode.children[2].tag).toBe('br')
-  })
-
-  it('render vnode with children, omitting data', () => {
-    const vm = new Vue({})
-    const h = vm.$createElement
-    const vnode = h('p', [h('br'), 'hello world', h('br')])
-    expect(vnode.children[0].tag).toBe('br')
-    expect(vnode.children[1].text).toBe('hello world')
-    expect(vnode.children[2].tag).toBe('br')
-  })
-
-  it('render vnode with children, including boolean and null type', () => {
-    const vm = new Vue({})
-    const h = vm.$createElement
-    const vnode = h('p', [h('br'), true, 123, h('br'), 'abc', null])
-    expect(vnode.children.length).toBe(4)
-    expect(vnode.children[0].tag).toBe('br')
-    expect(vnode.children[1].text).toBe('123')
-    expect(vnode.children[2].tag).toBe('br')
-    expect(vnode.children[3].text).toBe('abc')
-  })
-
-  it('render svg elements with correct namespace', () => {
-    const vm = new Vue({})
-    const h = vm.$createElement
-    const vnode = h('svg', [h('a', [h('foo', [h('bar')])])])
-    expect(vnode.ns).toBe('svg')
-    // should apply ns to children recursively
-    expect(vnode.children[0].ns).toBe('svg')
-    expect(vnode.children[0].children[0].ns).toBe('svg')
-    expect(vnode.children[0].children[0].children[0].ns).toBe('svg')
-  })
-
-  it('render MathML elements with correct namespace', () => {
-    const vm = new Vue({})
-    const h = vm.$createElement
-    const vnode = h('math', [h('matrix')])
-    expect(vnode.ns).toBe('math')
-    // should apply ns to children
-    expect(vnode.children[0].ns).toBe('math')
-    // although not explicitly listed, elements nested under <math>
-    // should not be treated as component
-    expect(vnode.children[0].componentOptions).toBeUndefined()
-  })
-
-  it('render svg foreignObject with correct namespace', () => {
-    const vm = new Vue({})
-    const h = vm.$createElement
-    const vnode = h('svg', [h('foreignObject', [h('p'), h('svg')])])
-    expect(vnode.ns).toBe('svg')
-    expect(vnode.children[0].ns).toBe('svg')
-    expect(vnode.children[0].children[0].ns).toBeUndefined()
-    // #7330
-    expect(vnode.children[0].children[1].ns).toBe('svg')
-  })
-
-  // #6642
-  it('render svg foreignObject component with correct namespace', () => {
-    const vm = new Vue({
-      template: `
-        <svg>
-          <test></test>
-        </svg>
-      `,
-      components: {
-        test: {
-          template: `
-          <foreignObject>
-            <p xmlns="http://www.w3.org/1999/xhtml"></p>
-          </foreignObject>
-          `
-        }
-      }
-    }).$mount()
-    const testComp = vm.$children[0]
-    expect(testComp.$vnode.ns).toBe('svg')
-    expect(testComp._vnode.tag).toBe('foreignObject')
-    expect(testComp._vnode.ns).toBe('svg')
-    expect(testComp._vnode.children[0].tag).toBe('p')
-    expect(testComp._vnode.children[0].ns).toBeUndefined()
-  })
-
-  // #6506
-  it('render SVGAElement in a component correctly', () => {
-    const vm = new Vue({
-      template: `
-        <svg>
-          <test></test>
-        </svg>
-      `,
-      components: {
-        test: { render: h => h('a') }
-      }
-    }).$mount()
-    const testComp = vm.$children[0]
-    expect(testComp.$vnode.ns).toBe('svg')
-    expect(testComp._vnode.tag).toBe('a')
-    expect(testComp._vnode.ns).toBe('svg')
-  })
-
-  it('warn observed data objects', () => {
-    new Vue({
-      data: {
-        data: {}
-      },
-      render (h) {
-        return h('div', this.data)
-      }
-    }).$mount()
-    expect('Avoid using observed data object as vnode data').toHaveBeenWarned()
-  })
-
-  it('warn non-primitive key', () => {
-    new Vue({
-      render (h) {
-        return h('div', { key: {}})
-      }
-    }).$mount()
-    expect('Avoid using non-primitive value as key').toHaveBeenWarned()
-  })
-
-  it('doesn\'t warn boolean key', () => {
-    new Vue({
-      render (h) {
-        return h('div', { key: true })
-      }
-    }).$mount()
-    expect('Avoid using non-primitive value as key').not.toHaveBeenWarned()
-  })
-
-  it('doesn\'t warn symbol key', () => {
-    new Vue({
-      render (h) {
-        return h('div', { key: Symbol('symbol') })
-      }
-    }).$mount()
-    expect('Avoid using non-primitive value as key').not.toHaveBeenWarned()
-  })
-
-  it('nested child elements should be updated correctly', done => {
-    const vm = new Vue({
-      data: { n: 1 },
-      render (h) {
-        const list = []
-        for (let i = 0; i < this.n; i++) {
-          list.push(h('span', i))
-        }
-        const input = h('input', {
-          attrs: {
-            value: 'a',
-            type: 'text'
-          }
-        })
-        return h('div', [[...list, input]])
-      }
-    }).$mount()
-    expect(vm.$el.innerHTML).toContain('<span>0</span><input')
-    const el = vm.$el.querySelector('input')
-    el.value = 'b'
-    vm.n++
-    waitForUpdate(() => {
-      expect(vm.$el.innerHTML).toContain('<span>0</span><span>1</span><input')
-      expect(vm.$el.querySelector('input')).toBe(el)
-      expect(vm.$el.querySelector('input').value).toBe('b')
-    }).then(done)
-  })
-
-  // #7786
-  it('creates element with vnode reference in :class or :style', () => {
-    const vm = new Vue({
-      components: {
-        foo: {
-          render (h) {
-            return h('div', {
-              class: {
-                'has-vnode': this.$vnode
-              }
-            }, 'foo')
-          }
-        }
-      },
-      render: h => h('foo')
-    }).$mount()
-    expect(vm.$el.innerHTML).toContain('foo')
-    expect(vm.$el.classList.contains('has-vnode')).toBe(true)
-  })
-})
diff --git a/1.Vue/test/unit/modules/vdom/modules/attrs.spec.js b/1.Vue/test/unit/modules/vdom/modules/attrs.spec.js
deleted file mode 100644
index 0ec1cc4..0000000
--- a/1.Vue/test/unit/modules/vdom/modules/attrs.spec.js
+++ /dev/null
@@ -1,102 +0,0 @@
-import Vue from 'vue'
-import { patch } from 'web/runtime/patch'
-import VNode from 'core/vdom/vnode'
-import { xlinkNS } from 'web/util/index'
-
-describe('vdom attrs module', () => {
-  it('should create an element with attrs', () => {
-    const vnode = new VNode('p', { attrs: { id: 1, class: 'class1' }})
-    const elm = patch(null, vnode)
-    expect(elm.id).toBe('1')
-    expect(elm).toHaveClass('class1')
-  })
-
-  it('should change the elements attrs', () => {
-    const vnode1 = new VNode('i', { attrs: { id: '1', class: 'i am vdom' }})
-    const vnode2 = new VNode('i', { attrs: { id: '2', class: 'i am' }})
-    patch(null, vnode1)
-    const elm = patch(vnode1, vnode2)
-    expect(elm.id).toBe('2')
-    expect(elm).toHaveClass('i')
-    expect(elm).toHaveClass('am')
-    expect(elm).not.toHaveClass('vdom')
-  })
-
-  it('should remove the elements attrs', () => {
-    const vnode1 = new VNode('i', { attrs: { id: '1', class: 'i am vdom' }})
-    const vnode2 = new VNode('i', { attrs: { id: '1' }})
-    patch(null, vnode1)
-    const elm = patch(vnode1, vnode2)
-    expect(elm.id).toBe('1')
-    expect(elm.className).toBe('')
-  })
-
-  it('should remove the elements attrs for new nodes without attrs data', () => {
-    const vnode1 = new VNode('i', { attrs: { id: '1', class: 'i am vdom' }})
-    const vnode2 = new VNode('i', {})
-    patch(null, vnode1)
-    const elm = patch(vnode1, vnode2)
-    expect(elm.id).toBe('')
-    expect(elm.className).toBe('')
-  })
-
-  it('should remove the falsy value from boolean attr', () => {
-    const vnode = new VNode('option', { attrs: { disabled: null }})
-    const elm = patch(null, vnode)
-    expect(elm.getAttribute('disabled')).toBe(null)
-  })
-
-  it('should set the attr name to boolean attr', () => {
-    const vnode = new VNode('option', { attrs: { disabled: true }})
-    const elm = patch(null, vnode)
-    expect(elm.getAttribute('disabled')).toBe('disabled')
-  })
-
-  it('should set the falsy value to enumerated attr', () => {
-    const vnode = new VNode('div', { attrs: { contenteditable: null }})
-    const elm = patch(null, vnode)
-    expect(elm.getAttribute('contenteditable')).toBe('false')
-  })
-
-  it('should set the boolean string value to enumerated attr', () => {
-    const vnode = new VNode('div', { attrs: { contenteditable: 'true' }})
-    const elm = patch(null, vnode)
-    expect(elm.getAttribute('contenteditable')).toBe('true')
-  })
-
-  it('should set the xlink value to attr', () => {
-    const vnode = new VNode('a', { attrs: { 'xlink:href': '#id1' }})
-    const elm = patch(null, vnode)
-    expect(elm.getAttributeNS(xlinkNS, 'href')).toBe('#id1')
-  })
-
-  it('should set the xlink boolean string value to attr', () => {
-    const vnode = new VNode('option', { attrs: { 'xlink:disabled': true }})
-    const elm = patch(null, vnode)
-    expect(elm.getAttributeNS(xlinkNS, 'disabled')).toBe('true')
-  })
-
-  it('should handle mutating observed attrs object', done => {
-    const vm = new Vue({
-      data: {
-        attrs: {
-          id: 'foo'
-        }
-      },
-      render (h) {
-        return h('div', {
-          attrs: this.attrs
-        })
-      }
-    }).$mount()
-
-    expect(vm.$el.id).toBe('foo')
-    vm.attrs.id = 'bar'
-    waitForUpdate(() => {
-      expect(vm.$el.id).toBe('bar')
-      vm.attrs = { id: 'baz' }
-    }).then(() => {
-      expect(vm.$el.id).toBe('baz')
-    }).then(done)
-  })
-})
diff --git a/1.Vue/test/unit/modules/vdom/modules/class.spec.js b/1.Vue/test/unit/modules/vdom/modules/class.spec.js
deleted file mode 100644
index 174e934..0000000
--- a/1.Vue/test/unit/modules/vdom/modules/class.spec.js
+++ /dev/null
@@ -1,107 +0,0 @@
-import { patch } from 'web/runtime/patch'
-import VNode from 'core/vdom/vnode'
-
-describe('vdom class module', () => {
-  it('should create an element with staticClass', () => {
-    const vnode = new VNode('p', { staticClass: 'class1' })
-    const elm = patch(null, vnode)
-    expect(elm).toHaveClass('class1')
-  })
-
-  it('should create an element with class', () => {
-    const vnode = new VNode('p', { class: 'class1' })
-    const elm = patch(null, vnode)
-    expect(elm).toHaveClass('class1')
-  })
-
-  it('should create an element with array class', () => {
-    const vnode = new VNode('p', { class: ['class1', 'class2'] })
-    const elm = patch(null, vnode)
-    expect(elm).toHaveClass('class1')
-    expect(elm).toHaveClass('class2')
-  })
-
-  it('should create an element with object class', () => {
-    const vnode = new VNode('p', {
-      class: { class1: true, class2: false, class3: true }
-    })
-    const elm = patch(null, vnode)
-    expect(elm).toHaveClass('class1')
-    expect(elm).not.toHaveClass('class2')
-    expect(elm).toHaveClass('class3')
-  })
-
-  it('should create an element with mixed class', () => {
-    const vnode = new VNode('p', {
-      class: [{ class1: false, class2: true, class3: false }, 'class4', ['class5', 'class6']]
-    })
-    const elm = patch(null, vnode)
-    expect(elm).not.toHaveClass('class1')
-    expect(elm).toHaveClass('class2')
-    expect(elm).not.toHaveClass('class3')
-    expect(elm).toHaveClass('class4')
-    expect(elm).toHaveClass('class5')
-    expect(elm).toHaveClass('class6')
-  })
-
-  it('should create an element with staticClass and class', () => {
-    const vnode = new VNode('p', { staticClass: 'class1', class: 'class2' })
-    const elm = patch(null, vnode)
-    expect(elm).toHaveClass('class1')
-    expect(elm).toHaveClass('class2')
-  })
-
-  it('should handle transition class', () => {
-    const vnode1 = new VNode('p', {
-      class: { class1: true, class2: false, class3: true }
-    })
-    let elm = patch(null, vnode1)
-    elm._transitionClasses = ['class4']
-    const vnode2 = new VNode('p', {
-      class: { class1: true, class2: true, class3: true }
-    })
-    elm = patch(vnode1, vnode2)
-    expect(elm).toHaveClass('class1')
-    expect(elm).toHaveClass('class2')
-    expect(elm).toHaveClass('class3')
-    expect(elm).toHaveClass('class4')
-  })
-
-  it('should change the elements class', () => {
-    const vnode1 = new VNode('p', {
-      class: { class1: true, class2: false, class3: true }
-    })
-    const vnode2 = new VNode('p', { staticClass: 'foo bar' })
-    let elm = patch(null, vnode1)
-    elm = patch(vnode1, vnode2)
-    expect(elm).not.toHaveClass('class1')
-    expect(elm).not.toHaveClass('class2')
-    expect(elm).not.toHaveClass('class3')
-    expect(elm).toHaveClass('foo')
-    expect(elm).toHaveClass('bar')
-  })
-
-  it('should remove the elements class', () => {
-    const vnode1 = new VNode('p', {
-      class: { class1: true, class2: false, class3: true }
-    })
-    const vnode2 = new VNode('p', { class: {}})
-    let elm = patch(null, vnode1)
-    elm = patch(vnode1, vnode2)
-    expect(elm).not.toHaveClass('class1')
-    expect(elm).not.toHaveClass('class2')
-    expect(elm).not.toHaveClass('class3')
-  })
-
-  it('should remove class for new nodes without class data', () => {
-    const vnode1 = new VNode('p', {
-      class: { class1: true, class2: false, class3: true }
-    })
-    const vnode2 = new VNode('p', {})
-    let elm = patch(null, vnode1)
-    elm = patch(vnode1, vnode2)
-    expect(elm).not.toHaveClass('class1')
-    expect(elm).not.toHaveClass('class2')
-    expect(elm).not.toHaveClass('class3')
-  })
-})
diff --git a/1.Vue/test/unit/modules/vdom/modules/directive.spec.js b/1.Vue/test/unit/modules/vdom/modules/directive.spec.js
deleted file mode 100644
index 38c5318..0000000
--- a/1.Vue/test/unit/modules/vdom/modules/directive.spec.js
+++ /dev/null
@@ -1,38 +0,0 @@
-import Vue from 'vue'
-import { patch } from 'web/runtime/patch'
-import VNode from 'core/vdom/vnode'
-
-describe('vdom directive module', () => {
-  it('should work', () => {
-    const directive1 = {
-      bind: jasmine.createSpy('bind'),
-      update: jasmine.createSpy('update'),
-      unbind: jasmine.createSpy('unbind')
-    }
-    const vm = new Vue({ directives: { directive1 }})
-    // create
-    const vnode1 = new VNode('div', {}, [
-      new VNode('p', {
-        directives: [{
-          name: 'directive1', value: 'hello', arg: 'arg1', modifiers: { modifier1: true }
-        }]
-      }, undefined, 'hello world', undefined, vm)
-    ])
-    patch(null, vnode1)
-    expect(directive1.bind).toHaveBeenCalled()
-    // update
-    const vnode2 = new VNode('div', {}, [
-      new VNode('p', {
-        directives: [{
-          name: 'directive1', value: 'world', arg: 'arg1', modifiers: { modifier1: true }
-        }]
-      }, undefined, 'hello world', undefined, vm)
-    ])
-    patch(vnode1, vnode2)
-    expect(directive1.update).toHaveBeenCalled()
-    // destroy
-    const vnode3 = new VNode('div')
-    patch(vnode2, vnode3)
-    expect(directive1.unbind).toHaveBeenCalled()
-  })
-})
diff --git a/1.Vue/test/unit/modules/vdom/modules/dom-props.spec.js b/1.Vue/test/unit/modules/vdom/modules/dom-props.spec.js
deleted file mode 100644
index 9017675..0000000
--- a/1.Vue/test/unit/modules/vdom/modules/dom-props.spec.js
+++ /dev/null
@@ -1,90 +0,0 @@
-import Vue from 'vue'
-import { patch } from 'web/runtime/patch'
-import VNode from 'core/vdom/vnode'
-
-describe('vdom domProps module', () => {
-  it('should create an element with domProps', () => {
-    const vnode = new VNode('a', { domProps: { src: 'http://localhost/' }})
-    const elm = patch(null, vnode)
-    expect(elm.src).toBe('http://localhost/')
-  })
-
-  it('should change the elements domProps', () => {
-    const vnode1 = new VNode('a', { domProps: { src: 'http://localhost/' }})
-    const vnode2 = new VNode('a', { domProps: { src: 'https://vuejs.org/' }})
-    patch(null, vnode1)
-    const elm = patch(vnode1, vnode2)
-    expect(elm.src).toBe('https://vuejs.org/')
-  })
-
-  it('should remove the elements domProps', () => {
-    const vnode1 = new VNode('a', { domProps: { src: 'http://localhost/' }})
-    const vnode2 = new VNode('a', { domProps: {}})
-    patch(null, vnode1)
-    const elm = patch(vnode1, vnode2)
-    expect(elm.src).toBe('')
-  })
-
-  it('should initialize the elements value to zero', () => {
-    const vnode = new VNode('input', { domProps: { value: 0 }})
-    const elm = patch(null, vnode)
-    expect(elm.value).toBe('0')
-  })
-
-  it('should save raw value on element', () => {
-    const value = {}
-    const vnode = new VNode('input', { domProps: { value }})
-    const elm = patch(null, vnode)
-    expect(elm._value).toBe(value)
-  })
-
-  it('should discard vnode children if the node has innerHTML or textContent as a prop', () => {
-    const vnode = new VNode('div', { domProps: { innerHTML: 'hi' }}, [
-      new VNode('span'), new VNode('span')
-    ])
-    const elm = patch(null, vnode)
-    expect(elm.innerHTML).toBe('hi')
-    expect(vnode.children.length).toBe(0)
-
-    const vnode2 = new VNode('div', { domProps: { textContent: 'hi' }}, [
-      new VNode('span'), new VNode('span')
-    ])
-    const elm2 = patch(null, vnode2)
-    expect(elm2.textContent).toBe('hi')
-    expect(vnode2.children.length).toBe(0)
-
-    const vnode3 = new VNode('div', undefined, undefined, '123')
-    patch(null, vnode3)
-    const elm3 = patch(vnode3, vnode2)
-    expect(elm3.textContent).toBe('hi')
-
-    const vnode4 = new VNode('div', undefined, undefined, new VNode('span'))
-    patch(null, vnode4)
-    const elm4 = patch(vnode4, vnode)
-    expect(elm4.textContent).toBe('hi')
-  })
-
-  it('should handle mutating observed props object', done => {
-    const vm = new Vue({
-      data: {
-        props: {
-          id: 'foo'
-        }
-      },
-      render (h) {
-        return h('div', {
-          domProps: this.props
-        })
-      }
-    }).$mount()
-
-    expect(vm.$el.id).toBe('foo')
-    vm.props.id = 'bar'
-    waitForUpdate(() => {
-      expect(vm.$el.id).toBe('bar')
-      vm.props = { id: 'baz' }
-    }).then(() => {
-      expect(vm.$el.id).toBe('baz')
-    }).then(done)
-  })
-})
diff --git a/1.Vue/test/unit/modules/vdom/modules/events.spec.js b/1.Vue/test/unit/modules/vdom/modules/events.spec.js
deleted file mode 100644
index 9dcd72c..0000000
--- a/1.Vue/test/unit/modules/vdom/modules/events.spec.js
+++ /dev/null
@@ -1,135 +0,0 @@
-import { patch } from 'web/runtime/patch'
-import VNode from 'core/vdom/vnode'
-
-describe('vdom events module', () => {
-  it('should attach event handler to element', () => {
-    const click = jasmine.createSpy()
-    const vnode = new VNode('a', { on: { click }})
-
-    const elm = patch(null, vnode)
-    document.body.appendChild(elm)
-    triggerEvent(elm, 'click')
-    expect(click.calls.count()).toBe(1)
-  })
-
-  it('should not duplicate the same listener', () => {
-    const click = jasmine.createSpy()
-    const vnode1 = new VNode('a', { on: { click }})
-    const vnode2 = new VNode('a', { on: { click }})
-
-    const elm = patch(null, vnode1)
-    patch(vnode1, vnode2)
-    document.body.appendChild(elm)
-    triggerEvent(elm, 'click')
-    expect(click.calls.count()).toBe(1)
-  })
-
-  it('should update different listener', () => {
-    const click = jasmine.createSpy()
-    const click2 = jasmine.createSpy()
-    const vnode1 = new VNode('a', { on: { click }})
-    const vnode2 = new VNode('a', { on: { click: click2 }})
-
-    const elm = patch(null, vnode1)
-    document.body.appendChild(elm)
-    triggerEvent(elm, 'click')
-    expect(click.calls.count()).toBe(1)
-    expect(click2.calls.count()).toBe(0)
-
-    patch(vnode1, vnode2)
-    triggerEvent(elm, 'click')
-    expect(click.calls.count()).toBe(1)
-    expect(click2.calls.count()).toBe(1)
-  })
-
-  it('should attach Array of multiple handlers', () => {
-    const click = jasmine.createSpy()
-    const vnode = new VNode('a', { on: { click: [click, click] }})
-
-    const elm = patch(null, vnode)
-    document.body.appendChild(elm)
-    triggerEvent(elm, 'click')
-    expect(click.calls.count()).toBe(2)
-  })
-
-  it('should update Array of multiple handlers', () => {
-    const click = jasmine.createSpy()
-    const click2 = jasmine.createSpy()
-    const vnode1 = new VNode('a', { on: { click: [click, click2] }})
-    const vnode2 = new VNode('a', { on: { click: [click] }})
-
-    const elm = patch(null, vnode1)
-    document.body.appendChild(elm)
-    triggerEvent(elm, 'click')
-    expect(click.calls.count()).toBe(1)
-    expect(click2.calls.count()).toBe(1)
-
-    patch(vnode1, vnode2)
-    triggerEvent(elm, 'click')
-    expect(click.calls.count()).toBe(2)
-    expect(click2.calls.count()).toBe(1)
-  })
-
-  it('should remove handlers that are no longer present', () => {
-    const click = jasmine.createSpy()
-    const vnode1 = new VNode('a', { on: { click }})
-    const vnode2 = new VNode('a', {})
-
-    const elm = patch(null, vnode1)
-    document.body.appendChild(elm)
-    triggerEvent(elm, 'click')
-    expect(click.calls.count()).toBe(1)
-
-    patch(vnode1, vnode2)
-    triggerEvent(elm, 'click')
-    expect(click.calls.count()).toBe(1)
-  })
-
-  it('should remove Array handlers that are no longer present', () => {
-    const click = jasmine.createSpy()
-    const vnode1 = new VNode('a', { on: { click: [click, click] }})
-    const vnode2 = new VNode('a', {})
-
-    const elm = patch(null, vnode1)
-    document.body.appendChild(elm)
-    triggerEvent(elm, 'click')
-    expect(click.calls.count()).toBe(2)
-
-    patch(vnode1, vnode2)
-    triggerEvent(elm, 'click')
-    expect(click.calls.count()).toBe(2)
-  })
-
-  // #4650
-  it('should handle single -> array or array -> single handler changes', () => {
-    const click = jasmine.createSpy()
-    const click2 = jasmine.createSpy()
-    const click3 = jasmine.createSpy()
-    const vnode0 = new VNode('a', { on: { click: click }})
-    const vnode1 = new VNode('a', { on: { click: [click, click2] }})
-    const vnode2 = new VNode('a', { on: { click: click }})
-    const vnode3 = new VNode('a', { on: { click: [click2, click3] }})
-
-    const elm = patch(null, vnode0)
-    document.body.appendChild(elm)
-    triggerEvent(elm, 'click')
-    expect(click.calls.count()).toBe(1)
-    expect(click2.calls.count()).toBe(0)
-
-    patch(vnode0, vnode1)
-    triggerEvent(elm, 'click')
-    expect(click.calls.count()).toBe(2)
-    expect(click2.calls.count()).toBe(1)
-
-    patch(vnode1, vnode2)
-    triggerEvent(elm, 'click')
-    expect(click.calls.count()).toBe(3)
-    expect(click2.calls.count()).toBe(1)
-
-    patch(vnode2, vnode3)
-    triggerEvent(elm, 'click')
-    expect(click.calls.count()).toBe(3)
-    expect(click2.calls.count()).toBe(2)
-    expect(click3.calls.count()).toBe(1)
-  })
-})
diff --git a/1.Vue/test/unit/modules/vdom/modules/style.spec.js b/1.Vue/test/unit/modules/vdom/modules/style.spec.js
deleted file mode 100644
index 13ee5fc..0000000
--- a/1.Vue/test/unit/modules/vdom/modules/style.spec.js
+++ /dev/null
@@ -1,35 +0,0 @@
-import { patch } from 'web/runtime/patch'
-import VNode from 'core/vdom/vnode'
-
-describe('vdom style module', () => {
-  it('should create an element with style', () => {
-    const vnode = new VNode('p', { style: { fontSize: '12px' }})
-    const elm = patch(null, vnode)
-    expect(elm.style.fontSize).toBe('12px')
-  })
-
-  it('should create an element with array style', () => {
-    const vnode = new VNode('p', { style: [{ fontSize: '12px' }, { color: 'red' }] })
-    const elm = patch(null, vnode)
-    expect(elm.style.fontSize).toBe('12px')
-    expect(elm.style.color).toBe('red')
-  })
-
-  it('should change elements style', () => {
-    const vnode1 = new VNode('p', { style: { fontSize: '12px' }})
-    const vnode2 = new VNode('p', { style: { fontSize: '10px', display: 'block' }})
-    patch(null, vnode1)
-    const elm = patch(vnode1, vnode2)
-    expect(elm.style.fontSize).toBe('10px')
-    expect(elm.style.display).toBe('block')
-  })
-
-  it('should remove elements attrs', () => {
-    const vnode1 = new VNode('p', { style: { fontSize: '12px' }})
-    const vnode2 = new VNode('p', { style: { display: 'block' }})
-    patch(null, vnode1)
-    const elm = patch(vnode1, vnode2)
-    expect(elm.style.fontSize).toBe('')
-    expect(elm.style.display).toBe('block')
-  })
-})
diff --git a/1.Vue/test/unit/modules/vdom/patch/children.spec.js b/1.Vue/test/unit/modules/vdom/patch/children.spec.js
deleted file mode 100644
index f42c541..0000000
--- a/1.Vue/test/unit/modules/vdom/patch/children.spec.js
+++ /dev/null
@@ -1,545 +0,0 @@
-import { patch } from 'web/runtime/patch'
-import VNode, { createEmptyVNode } from 'core/vdom/vnode'
-
-function prop (name) {
-  return obj => { return obj[name] }
-}
-
-function map (fn, list) {
-  const ret = []
-  for (let i = 0; i < list.length; i++) {
-    ret[i] = fn(list[i])
-  }
-  return ret
-}
-
-function spanNum (n) {
-  if (typeof n === 'string') {
-    return new VNode('span', {}, undefined, n)
-  } else {
-    return new VNode('span', { key: n }, undefined, n.toString())
-  }
-}
-
-function shuffle (array) {
-  let currentIndex = array.length
-  let temporaryValue
-  let randomIndex
-
-  // while there remain elements to shuffle...
-  while (currentIndex !== 0) {
-    // pick a remaining element...
-    randomIndex = Math.floor(Math.random() * currentIndex)
-    currentIndex -= 1
-    // and swap it with the current element.
-    temporaryValue = array[currentIndex]
-    array[currentIndex] = array[randomIndex]
-    array[randomIndex] = temporaryValue
-  }
-  return array
-}
-
-const inner = prop('innerHTML')
-const tag = prop('tagName')
-
-describe('vdom patch: children', () => {
-  let vnode0
-  beforeEach(() => {
-    vnode0 = new VNode('p', { attrs: { id: '1' }}, [createTextVNode('hello world')])
-    patch(null, vnode0)
-  })
-
-  it('should appends elements', () => {
-    const vnode1 = new VNode('p', {}, [1].map(spanNum))
-    const vnode2 = new VNode('p', {}, [1, 2, 3].map(spanNum))
-    let elm = patch(vnode0, vnode1)
-    expect(elm.children.length).toBe(1)
-    elm = patch(vnode1, vnode2)
-    expect(elm.children.length).toBe(3)
-    expect(elm.children[1].innerHTML).toBe('2')
-    expect(elm.children[2].innerHTML).toBe('3')
-  })
-
-  it('should prepends elements', () => {
-    const vnode1 = new VNode('p', {}, [4, 5].map(spanNum))
-    const vnode2 = new VNode('p', {}, [1, 2, 3, 4, 5].map(spanNum))
-    let elm = patch(vnode0, vnode1)
-    expect(elm.children.length).toBe(2)
-    elm = patch(vnode1, vnode2)
-    expect(map(inner, elm.children)).toEqual(['1', '2', '3', '4', '5'])
-  })
-
-  it('should add elements in the middle', () => {
-    const vnode1 = new VNode('p', {}, [1, 2, 4, 5].map(spanNum))
-    const vnode2 = new VNode('p', {}, [1, 2, 3, 4, 5].map(spanNum))
-    let elm = patch(vnode0, vnode1)
-    expect(elm.children.length).toBe(4)
-    elm = patch(vnode1, vnode2)
-    expect(map(inner, elm.children)).toEqual(['1', '2', '3', '4', '5'])
-  })
-
-  it('should add elements at begin and end', () => {
-    const vnode1 = new VNode('p', {}, [2, 3, 4].map(spanNum))
-    const vnode2 = new VNode('p', {}, [1, 2, 3, 4, 5].map(spanNum))
-    let elm = patch(vnode0, vnode1)
-    expect(elm.children.length).toBe(3)
-    elm = patch(vnode1, vnode2)
-    expect(map(inner, elm.children)).toEqual(['1', '2', '3', '4', '5'])
-  })
-
-  it('should add children to parent with no children', () => {
-    const vnode1 = new VNode('p', { key: 'p' })
-    const vnode2 = new VNode('p', { key: 'p' }, [1, 2, 3].map(spanNum))
-    let elm = patch(vnode0, vnode1)
-    expect(elm.children.length).toBe(0)
-    elm = patch(vnode1, vnode2)
-    expect(map(inner, elm.children)).toEqual(['1', '2', '3'])
-  })
-
-  it('should remove all children from parent', () => {
-    const vnode1 = new VNode('p', { key: 'p' }, [1, 2, 3].map(spanNum))
-    const vnode2 = new VNode('p', { key: 'p' })
-    let elm = patch(vnode0, vnode1)
-    expect(map(inner, elm.children)).toEqual(['1', '2', '3'])
-    elm = patch(vnode1, vnode2)
-    expect(elm.children.length).toBe(0)
-  })
-
-  it('should remove elements from the beginning', () => {
-    const vnode1 = new VNode('p', {}, [1, 2, 3, 4, 5].map(spanNum))
-    const vnode2 = new VNode('p', {}, [3, 4, 5].map(spanNum))
-    let elm = patch(vnode0, vnode1)
-    expect(elm.children.length).toBe(5)
-    elm = patch(vnode1, vnode2)
-    expect(map(inner, elm.children)).toEqual(['3', '4', '5'])
-  })
-
-  it('should removes elements from end', () => {
-    const vnode1 = new VNode('p', {}, [1, 2, 3, 4, 5].map(spanNum))
-    const vnode2 = new VNode('p', {}, [1, 2, 3].map(spanNum))
-    let elm = patch(vnode0, vnode1)
-    expect(elm.children.length).toBe(5)
-    elm = patch(vnode1, vnode2)
-    expect(elm.children.length).toBe(3)
-    expect(map(inner, elm.children)).toEqual(['1', '2', '3'])
-  })
-
-  it('should remove elements from the middle', () => {
-    const vnode1 = new VNode('p', {}, [1, 2, 3, 4, 5].map(spanNum))
-    const vnode2 = new VNode('p', {}, [1, 2, 4, 5].map(spanNum))
-    let elm = patch(vnode0, vnode1)
-    expect(elm.children.length).toBe(5)
-    elm = patch(vnode1, vnode2)
-    expect(elm.children.length).toBe(4)
-    expect(map(inner, elm.children)).toEqual(['1', '2', '4', '5'])
-  })
-
-  it('should moves element forward', () => {
-    const vnode1 = new VNode('p', {}, [1, 2, 3, 4].map(spanNum))
-    const vnode2 = new VNode('p', {}, [2, 3, 1, 4].map(spanNum))
-    let elm = patch(vnode0, vnode1)
-    expect(elm.children.length).toBe(4)
-    elm = patch(vnode1, vnode2)
-    expect(elm.children.length).toBe(4)
-    expect(map(inner, elm.children)).toEqual(['2', '3', '1', '4'])
-  })
-
-  it('should move elements to end', () => {
-    const vnode1 = new VNode('p', {}, [1, 2, 3].map(spanNum))
-    const vnode2 = new VNode('p', {}, [2, 3, 1].map(spanNum))
-    let elm = patch(vnode0, vnode1)
-    expect(elm.children.length).toBe(3)
-    elm = patch(vnode1, vnode2)
-    expect(elm.children.length).toBe(3)
-    expect(map(inner, elm.children)).toEqual(['2', '3', '1'])
-  })
-
-  it('should move element backwards', () => {
-    const vnode1 = new VNode('p', {}, [1, 2, 3, 4].map(spanNum))
-    const vnode2 = new VNode('p', {}, [1, 4, 2, 3].map(spanNum))
-    let elm = patch(vnode0, vnode1)
-    expect(elm.children.length).toBe(4)
-    elm = patch(vnode1, vnode2)
-    expect(elm.children.length).toBe(4)
-    expect(map(inner, elm.children)).toEqual(['1', '4', '2', '3'])
-  })
-
-  it('should swap first and last', () => {
-    const vnode1 = new VNode('p', {}, [1, 2, 3, 4].map(spanNum))
-    const vnode2 = new VNode('p', {}, [4, 2, 3, 1].map(spanNum))
-    let elm = patch(vnode0, vnode1)
-    expect(elm.children.length).toBe(4)
-    elm = patch(vnode1, vnode2)
-    expect(elm.children.length).toBe(4)
-    expect(map(inner, elm.children)).toEqual(['4', '2', '3', '1'])
-  })
-
-  it('should move to left and replace', () => {
-    const vnode1 = new VNode('p', {}, [1, 2, 3, 4, 5].map(spanNum))
-    const vnode2 = new VNode('p', {}, [4, 1, 2, 3, 6].map(spanNum))
-    let elm = patch(vnode0, vnode1)
-    expect(elm.children.length).toBe(5)
-    elm = patch(vnode1, vnode2)
-    expect(elm.children.length).toBe(5)
-    expect(map(inner, elm.children)).toEqual(['4', '1', '2', '3', '6'])
-  })
-
-  it('should move to left and leaves hold', () => {
-    const vnode1 = new VNode('p', {}, [1, 4, 5].map(spanNum))
-    const vnode2 = new VNode('p', {}, [4, 6].map(spanNum))
-    let elm = patch(vnode0, vnode1)
-    expect(elm.children.length).toBe(3)
-    elm = patch(vnode1, vnode2)
-    expect(map(inner, elm.children)).toEqual(['4', '6'])
-  })
-
-  it('should handle moved and set to undefined element ending at the end', () => {
-    const vnode1 = new VNode('p', {}, [2, 4, 5].map(spanNum))
-    const vnode2 = new VNode('p', {}, [4, 5, 3].map(spanNum))
-    let elm = patch(vnode0, vnode1)
-    expect(elm.children.length).toBe(3)
-    elm = patch(vnode1, vnode2)
-    expect(elm.children.length).toBe(3)
-    expect(map(inner, elm.children)).toEqual(['4', '5', '3'])
-  })
-
-  it('should move a key in non-keyed nodes with a size up', () => {
-    const vnode1 = new VNode('p', {}, [1, 'a', 'b', 'c'].map(spanNum))
-    const vnode2 = new VNode('p', {}, ['d', 'a', 'b', 'c', 1, 'e'].map(spanNum))
-    let elm = patch(vnode0, vnode1)
-    expect(elm.children.length).toBe(4)
-    expect(elm.textContent, '1abc')
-    elm = patch(vnode1, vnode2)
-    expect(elm.children.length).toBe(6)
-    expect(elm.textContent, 'dabc1e')
-  })
-
-  it('should reverse element', () => {
-    const vnode1 = new VNode('p', {}, [1, 2, 3, 4, 5, 6, 7, 8].map(spanNum))
-    const vnode2 = new VNode('p', {}, [8, 7, 6, 5, 4, 3, 2, 1].map(spanNum))
-    let elm = patch(vnode0, vnode1)
-    expect(elm.children.length).toBe(8)
-    elm = patch(vnode1, vnode2)
-    expect(map(inner, elm.children)).toEqual(['8', '7', '6', '5', '4', '3', '2', '1'])
-  })
-
-  it('something', () => {
-    const vnode1 = new VNode('p', {}, [0, 1, 2, 3, 4, 5].map(spanNum))
-    const vnode2 = new VNode('p', {}, [4, 3, 2, 1, 5, 0].map(spanNum))
-    let elm = patch(vnode0, vnode1)
-    expect(elm.children.length).toBe(6)
-    elm = patch(vnode1, vnode2)
-    expect(map(inner, elm.children)).toEqual(['4', '3', '2', '1', '5', '0'])
-  })
-
-  it('should handle random shuffle', () => {
-    let n
-    let i
-    const arr = []
-    const opacities = []
-    const elms = 14
-    const samples = 5
-    function spanNumWithOpacity (n, o) {
-      return new VNode('span', { key: n, style: { opacity: o }}, undefined, n.toString())
-    }
-
-    for (n = 0; n < elms; ++n) { arr[n] = n }
-    for (n = 0; n < samples; ++n) {
-      const vnode1 = new VNode('span', {}, arr.map(n => {
-        return spanNumWithOpacity(n, '1')
-      }))
-      const shufArr = shuffle(arr.slice(0))
-      let elm = patch(vnode0, vnode1)
-      for (i = 0; i < elms; ++i) {
-        expect(elm.children[i].innerHTML).toBe(i.toString())
-        opacities[i] = Math.random().toFixed(5).toString()
-      }
-      const vnode2 = new VNode('span', {}, arr.map(n => {
-        return spanNumWithOpacity(shufArr[n], opacities[n])
-      }))
-      elm = patch(vnode1, vnode2)
-      for (i = 0; i < elms; ++i) {
-        expect(elm.children[i].innerHTML).toBe(shufArr[i].toString())
-        expect(opacities[i].indexOf(elm.children[i].style.opacity)).toBe(0)
-      }
-    }
-  })
-
-  it('should append elements with updating children without keys', () => {
-    const vnode1 = new VNode('div', {}, [
-      new VNode('span', {}, undefined, 'hello')
-    ])
-    const vnode2 = new VNode('div', {}, [
-      new VNode('span', {}, undefined, 'hello'),
-      new VNode('span', {}, undefined, 'world')
-    ])
-    let elm = patch(vnode0, vnode1)
-    expect(map(inner, elm.children)).toEqual(['hello'])
-    elm = patch(vnode1, vnode2)
-    expect(map(inner, elm.children)).toEqual(['hello', 'world'])
-  })
-
-  it('should handle unmoved text nodes with updating children without keys', () => {
-    const vnode1 = new VNode('div', {}, [
-      createTextVNode('text'),
-      new VNode('span', {}, undefined, 'hello')
-    ])
-    const vnode2 = new VNode('div', {}, [
-      createTextVNode('text'),
-      new VNode('span', {}, undefined, 'hello')
-    ])
-    let elm = patch(vnode0, vnode1)
-    expect(elm.childNodes[0].textContent).toBe('text')
-    elm = patch(vnode1, vnode2)
-    expect(elm.childNodes[0].textContent).toBe('text')
-  })
-
-  it('should handle changing text children with updating children without keys', () => {
-    const vnode1 = new VNode('div', {}, [
-      createTextVNode('text'),
-      new VNode('span', {}, undefined, 'hello')
-    ])
-    const vnode2 = new VNode('div', {}, [
-      createTextVNode('text2'),
-      new VNode('span', {}, undefined, 'hello')
-    ])
-    let elm = patch(vnode0, vnode1)
-    expect(elm.childNodes[0].textContent).toBe('text')
-    elm = patch(vnode1, vnode2)
-    expect(elm.childNodes[0].textContent).toBe('text2')
-  })
-
-  it('should prepend element with updating children without keys', () => {
-    const vnode1 = new VNode('div', {}, [
-      new VNode('span', {}, undefined, 'world')
-    ])
-    const vnode2 = new VNode('div', {}, [
-      new VNode('span', {}, undefined, 'hello'),
-      new VNode('span', {}, undefined, 'world')
-    ])
-    let elm = patch(vnode0, vnode1)
-    expect(map(inner, elm.children)).toEqual(['world'])
-    elm = patch(vnode1, vnode2)
-    expect(map(inner, elm.children)).toEqual(['hello', 'world'])
-  })
-
-  it('should prepend element of different tag type with updating children without keys', () => {
-    const vnode1 = new VNode('div', {}, [
-      new VNode('span', {}, undefined, 'world')
-    ])
-    const vnode2 = new VNode('div', {}, [
-      new VNode('div', {}, undefined, 'hello'),
-      new VNode('span', {}, undefined, 'world')
-    ])
-    let elm = patch(vnode0, vnode1)
-    expect(map(inner, elm.children)).toEqual(['world'])
-    elm = patch(vnode1, vnode2)
-    expect(map(prop('tagName'), elm.children)).toEqual(['DIV', 'SPAN'])
-    expect(map(inner, elm.children)).toEqual(['hello', 'world'])
-  })
-
-  it('should remove elements with updating children without keys', () => {
-    const vnode1 = new VNode('div', {}, [
-      new VNode('span', {}, undefined, 'one'),
-      new VNode('span', {}, undefined, 'two'),
-      new VNode('span', {}, undefined, 'three')
-    ])
-    const vnode2 = new VNode('div', {}, [
-      new VNode('span', {}, undefined, 'one'),
-      new VNode('span', {}, undefined, 'three')
-    ])
-    let elm = patch(vnode0, vnode1)
-    expect(map(inner, elm.children)).toEqual(['one', 'two', 'three'])
-    elm = patch(vnode1, vnode2)
-    expect(map(inner, elm.children)).toEqual(['one', 'three'])
-  })
-
-  it('should remove a single text node with updating children without keys', () => {
-    const vnode1 = new VNode('div', {}, undefined, 'one')
-    const vnode2 = new VNode('div', {})
-    let elm = patch(vnode0, vnode1)
-    expect(elm.textContent).toBe('one')
-    elm = patch(vnode1, vnode2)
-    expect(elm.textContent).toBe('')
-  })
-
-  it('should remove a single text node when children are updated', () => {
-    const vnode1 = new VNode('div', {}, undefined, 'one')
-    const vnode2 = new VNode('div', {}, [
-      new VNode('div', {}, undefined, 'two'),
-      new VNode('span', {}, undefined, 'three')
-    ])
-    let elm = patch(vnode0, vnode1)
-    expect(elm.textContent).toBe('one')
-    elm = patch(vnode1, vnode2)
-    expect(map(prop('textContent'), elm.childNodes)).toEqual(['two', 'three'])
-  })
-
-  it('should remove a text node among other elements', () => {
-    const vnode1 = new VNode('div', {}, [
-      createTextVNode('one'),
-      new VNode('span', {}, undefined, 'two')
-    ])
-    const vnode2 = new VNode('div', {}, [
-      new VNode('div', {}, undefined, 'three')
-    ])
-    let elm = patch(vnode0, vnode1)
-    expect(map(prop('textContent'), elm.childNodes)).toEqual(['one', 'two'])
-    elm = patch(vnode1, vnode2)
-    expect(elm.childNodes.length).toBe(1)
-    expect(elm.childNodes[0].tagName).toBe('DIV')
-    expect(elm.childNodes[0].textContent).toBe('three')
-  })
-
-  it('should reorder elements', () => {
-    const vnode1 = new VNode('div', {}, [
-      new VNode('span', {}, undefined, 'one'),
-      new VNode('div', {}, undefined, 'two'),
-      new VNode('b', {}, undefined, 'three')
-    ])
-    const vnode2 = new VNode('div', {}, [
-      new VNode('b', {}, undefined, 'three'),
-      new VNode('span', {}, undefined, 'two'),
-      new VNode('div', {}, undefined, 'one')
-    ])
-    let elm = patch(vnode0, vnode1)
-    expect(map(inner, elm.children)).toEqual(['one', 'two', 'three'])
-    elm = patch(vnode1, vnode2)
-    expect(map(inner, elm.children)).toEqual(['three', 'two', 'one'])
-  })
-
-  it('should handle children with the same key but with different tag', () => {
-    const vnode1 = new VNode('div', {}, [
-      new VNode('div', { key: 1 }, undefined, 'one'),
-      new VNode('div', { key: 2 }, undefined, 'two'),
-      new VNode('div', { key: 3 }, undefined, 'three'),
-      new VNode('div', { key: 4 }, undefined, 'four')
-    ])
-    const vnode2 = new VNode('div', {}, [
-      new VNode('div', { key: 4 }, undefined, 'four'),
-      new VNode('span', { key: 3 }, undefined, 'three'),
-      new VNode('span', { key: 2 }, undefined, 'two'),
-      new VNode('div', { key: 1 }, undefined, 'one')
-    ])
-    let elm = patch(vnode0, vnode1)
-    expect(map(tag, elm.children)).toEqual(['DIV', 'DIV', 'DIV', 'DIV'])
-    expect(map(inner, elm.children)).toEqual(['one', 'two', 'three', 'four'])
-    elm = patch(vnode1, vnode2)
-    expect(map(tag, elm.children)).toEqual(['DIV', 'SPAN', 'SPAN', 'DIV'])
-    expect(map(inner, elm.children)).toEqual(['four', 'three', 'two', 'one'])
-  })
-
-  it('should handle children with the same tag, same key, but one with data and one without data', () => {
-    const vnode1 = new VNode('div', {}, [
-      new VNode('div', { class: 'hi' }, undefined, 'one')
-    ])
-    const vnode2 = new VNode('div', {}, [
-      new VNode('div', undefined, undefined, 'four')
-    ])
-    let elm = patch(vnode0, vnode1)
-    const child1 = elm.children[0]
-    expect(child1.className).toBe('hi')
-    elm = patch(vnode1, vnode2)
-    const child2 = elm.children[0]
-    expect(child1).not.toBe(child2)
-    expect(child2.className).toBe('')
-  })
-
-  it('should handle static vnodes properly', () => {
-    function makeNode (text) {
-      return new VNode('div', undefined, [
-        new VNode(undefined, undefined, undefined, text)
-      ])
-    }
-    const b = makeNode('B')
-    b.isStatic = true
-    b.key = `__static__1`
-    const vnode1 = new VNode('div', {}, [makeNode('A'), b, makeNode('C')])
-    const vnode2 = new VNode('div', {}, [b])
-    const vnode3 = new VNode('div', {}, [makeNode('A'), b, makeNode('C')])
-
-    let elm = patch(vnode0, vnode1)
-    expect(elm.textContent).toBe('ABC')
-    elm = patch(vnode1, vnode2)
-    expect(elm.textContent).toBe('B')
-    elm = patch(vnode2, vnode3)
-    expect(elm.textContent).toBe('ABC')
-  })
-
-  it('should handle static vnodes inside ', () => {
-    function makeNode (text) {
-      return new VNode('div', undefined, [
-        new VNode(undefined, undefined, undefined, text)
-      ])
-    }
-    const b = makeNode('B')
-    b.isStatic = true
-    b.key = `__static__1`
-    const vnode1 = new VNode('div', {}, [makeNode('A'), b, makeNode('C')])
-    const vnode2 = new VNode('div', {}, [b])
-    const vnode3 = new VNode('div', {}, [makeNode('A'), b, makeNode('C')])
-
-    let elm = patch(vnode0, vnode1)
-    expect(elm.textContent).toBe('ABC')
-    elm = patch(vnode1, vnode2)
-    expect(elm.textContent).toBe('B')
-    elm = patch(vnode2, vnode3)
-    expect(elm.textContent).toBe('ABC')
-  })
-
-  // #6502
-  it('should not de-opt when both head and tail are changed', () => {
-    const vnode1 = new VNode('div', {}, [
-      createEmptyVNode(),
-      new VNode('div'),
-      createEmptyVNode()
-    ])
-    const vnode2 = new VNode('div', {}, [
-      new VNode('p'),
-      new VNode('div'),
-      new VNode('p')
-    ])
-    let root = patch(null, vnode1)
-    const original = root.childNodes[1]
-
-    root = patch(vnode1, vnode2)
-    const postPatch = root.childNodes[1]
-
-    expect(postPatch).toBe(original)
-  })
-
-  it('should warn with duplicate keys: createChildren', () => {
-    function makeNode (key) {
-      return new VNode('div', { key: key })
-    }
-
-    const vnode = new VNode('p', {}, ['b', 'a', 'c', 'b'].map(makeNode))
-    patch(null, vnode)
-    expect(`Duplicate keys detected: 'b'`).toHaveBeenWarned()
-  })
-
-  it('should warn with duplicate keys: updateChildren', () => {
-    function makeNode (key) {
-      return new VNode('div', { key: key })
-    }
-
-    const vnode2 = new VNode('p', {}, ['b', 'a', 'c', 'b'].map(makeNode))
-    const vnode3 = new VNode('p', {}, ['b', 'x', 'd', 'b'].map(makeNode))
-    patch(vnode0, vnode2)
-    expect(`Duplicate keys detected: 'b'`).toHaveBeenWarned()
-    patch(vnode2, vnode3)
-    expect(`Duplicate keys detected: 'b'`).toHaveBeenWarned()
-  })
-
-  it('should warn with duplicate keys: patchVnode with empty oldVnode', () => {
-    function makeNode (key) {
-      return new VNode('li', { key: key })
-    }
-
-    const vnode1 = new VNode('div')
-    const vnode2 = new VNode('div', undefined, ['1', '2', '3', '4', '4'].map(makeNode))
-
-    patch(vnode1, vnode2)
-    expect(`Duplicate keys detected: '4'`).toHaveBeenWarned()
-  })
-})
diff --git a/1.Vue/test/unit/modules/vdom/patch/edge-cases.spec.js b/1.Vue/test/unit/modules/vdom/patch/edge-cases.spec.js
deleted file mode 100644
index a7f7ba3..0000000
--- a/1.Vue/test/unit/modules/vdom/patch/edge-cases.spec.js
+++ /dev/null
@@ -1,435 +0,0 @@
-import Vue from 'vue'
-
-describe('vdom patch: edge cases', () => {
-  // exposed by #3406
-  // When a static vnode is inside v-for, it's possible for the same vnode
-  // to be used in multiple places, and its element will be replaced. This
-  // causes patch errors when node ops depend on the vnode's element position.
-  it('should handle static vnodes by key', done => {
-    const vm = new Vue({
-      data: {
-        ok: true
-      },
-      template: `
-        <div>
-          <div v-for="i in 2">
-            <div v-if="ok">a</div><div>b</div><div v-if="!ok">c</div><div>d</div>
-          </div>
-        </div>
-      `
-    }).$mount()
-    expect(vm.$el.textContent).toBe('abdabd')
-    vm.ok = false
-    waitForUpdate(() => {
-      expect(vm.$el.textContent).toBe('bcdbcd')
-    }).then(done)
-  })
-
-  // exposed by #7705
-  // methods and function expressions with modifiers should return result instead of undefined
-  // skipped odd children[1,3, ...] because they are rendered as text nodes with undefined value
-  it('should return listener\'s result for method name and function expression with and w/o modifiers', done => {
-    const dummyEvt = { preventDefault: () => {} }
-    new Vue({
-      template: `
-        <div v-test>
-          <div @click="addFive"></div>
-          <div @click.prevent="addFive"></div>
-          <div @click="addFive($event, 5)"></div>
-          <div @click.prevent="addFive($event, 5)"></div>
-        </div>
-      `,
-      methods: {
-        addFive ($event, toAdd = 0) {
-          return toAdd + 5
-        }
-      },
-      directives: {
-        test: {
-          bind (el, binding, vnode) {
-            waitForUpdate(() => {
-              expect(vnode.children[0].data.on.click()).toBe(5)
-              expect(vnode.children[2].data.on.click(dummyEvt)).toBe(5)
-              expect(vnode.children[4].data.on.click()).toBe(10)
-              expect(vnode.children[6].data.on.click(dummyEvt)).toBe(10)
-            }).then(done)
-          }
-        }
-      }
-    }).$mount()
-  })
-
-  // #3533
-  // a static node is reused in createElm, which changes its elm reference
-  // and is inserted into a different parent.
-  // later when patching the next element a DOM insertion uses it as the
-  // reference node, causing a parent mismatch.
-  it('should handle static node edge case when it\'s reused AND used as a reference node for insertion', done => {
-    const vm = new Vue({
-      data: {
-        ok: true
-      },
-      template: `
-        <div>
-          <button @click="ok = !ok">toggle</button>
-          <div class="b" v-if="ok">123</div>
-          <div class="c">
-            <div><span/></div><p>{{ 1 }}</p>
-          </div>
-          <div class="d">
-            <label>{{ 2 }}</label>
-          </div>
-          <div class="b" v-if="ok">123</div>
-        </div>
-      `
-    }).$mount()
-
-    expect(vm.$el.querySelector('.c').textContent).toBe('1')
-    expect(vm.$el.querySelector('.d').textContent).toBe('2')
-    vm.ok = false
-    waitForUpdate(() => {
-      expect(vm.$el.querySelector('.c').textContent).toBe('1')
-      expect(vm.$el.querySelector('.d').textContent).toBe('2')
-    }).then(done)
-  })
-
-  it('should handle slot nodes being reused across render', done => {
-    const vm = new Vue({
-      template: `
-        <foo ref="foo">
-          <div>slot</div>
-        </foo>
-      `,
-      components: {
-        foo: {
-          data () {
-            return { ok: true }
-          },
-          render (h) {
-            const children = [
-              this.ok ? h('div', 'toggler ') : null,
-              h('div', [this.$slots.default, h('span', ' 1')]),
-              h('div', [h('label', ' 2')])
-            ]
-            return h('div', children)
-          }
-        }
-      }
-    }).$mount()
-    expect(vm.$el.textContent).toContain('toggler slot 1 2')
-    vm.$refs.foo.ok = false
-    waitForUpdate(() => {
-      expect(vm.$el.textContent).toContain('slot 1 2')
-      vm.$refs.foo.ok = true
-    }).then(() => {
-      expect(vm.$el.textContent).toContain('toggler slot 1 2')
-      vm.$refs.foo.ok = false
-    }).then(() => {
-      expect(vm.$el.textContent).toContain('slot 1 2')
-      vm.$refs.foo.ok = true
-    }).then(done)
-  })
-
-  it('should synchronize vm\' vnode', done => {
-    const comp = {
-      data: () => ({ swap: true }),
-      render (h) {
-        return this.swap
-          ? h('a', 'atag')
-          : h('span', 'span')
-      }
-    }
-
-    const wrapper = {
-      render: h => h('comp'),
-      components: { comp }
-    }
-
-    const vm = new Vue({
-      render (h) {
-        const children = [
-          h('wrapper'),
-          h('div', 'row')
-        ]
-        if (this.swap) {
-          children.reverse()
-        }
-        return h('div', children)
-      },
-      data: () => ({ swap: false }),
-      components: { wrapper }
-    }).$mount()
-
-    expect(vm.$el.innerHTML).toBe('<a>atag</a><div>row</div>')
-    const wrapperVm = vm.$children[0]
-    const compVm = wrapperVm.$children[0]
-    vm.swap = true
-    waitForUpdate(() => {
-      expect(compVm.$vnode.parent).toBe(wrapperVm.$vnode)
-      expect(vm.$el.innerHTML).toBe('<div>row</div><a>atag</a>')
-      vm.swap = false
-    }).then(() => {
-      expect(compVm.$vnode.parent).toBe(wrapperVm.$vnode)
-      expect(vm.$el.innerHTML).toBe('<a>atag</a><div>row</div>')
-      compVm.swap = false
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<span>span</span><div>row</div>')
-      expect(compVm.$vnode.parent).toBe(wrapperVm.$vnode)
-      vm.swap = true
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<div>row</div><span>span</span>')
-      expect(compVm.$vnode.parent).toBe(wrapperVm.$vnode)
-      vm.swap = true
-    }).then(done)
-  })
-
-  // #4530
-  it('should not reset value when patching between dynamic/static bindings', done => {
-    const vm = new Vue({
-      data: { ok: true },
-      template: `
-        <div>
-          <input type="button" v-if="ok" value="a">
-          <input type="button" :value="'b'">
-        </div>
-      `
-    }).$mount()
-    expect(vm.$el.children[0].value).toBe('a')
-    vm.ok = false
-    waitForUpdate(() => {
-      expect(vm.$el.children[0].value).toBe('b')
-      vm.ok = true
-    }).then(() => {
-      expect(vm.$el.children[0].value).toBe('a')
-    }).then(done)
-  })
-
-  // #6313
-  it('should not replace node when switching between text-like inputs', done => {
-    const vm = new Vue({
-      data: { show: false },
-      template: `
-        <div>
-          <input :type="show ? 'text' : 'password'">
-        </div>
-      `
-    }).$mount()
-    const node = vm.$el.children[0]
-    expect(vm.$el.children[0].type).toBe('password')
-    vm.$el.children[0].value = 'test'
-    vm.show = true
-    waitForUpdate(() => {
-      expect(vm.$el.children[0]).toBe(node)
-      expect(vm.$el.children[0].value).toBe('test')
-      expect(vm.$el.children[0].type).toBe('text')
-      vm.show = false
-    }).then(() => {
-      expect(vm.$el.children[0]).toBe(node)
-      expect(vm.$el.children[0].value).toBe('test')
-      expect(vm.$el.children[0].type).toBe('password')
-    }).then(done)
-  })
-
-  it('should properly patch nested HOC when root element is replaced', done => {
-    const vm = new Vue({
-      template: `<foo class="hello" ref="foo" />`,
-      components: {
-        foo: {
-          template: `<bar ref="bar" />`,
-          components: {
-            bar: {
-              template: `<div v-if="ok"></div><span v-else></span>`,
-              data () {
-                return { ok: true }
-              }
-            }
-          }
-        }
-      }
-    }).$mount()
-
-    expect(vm.$refs.foo.$refs.bar.$el.tagName).toBe('DIV')
-    expect(vm.$refs.foo.$refs.bar.$el.className).toBe(`hello`)
-
-    vm.$refs.foo.$refs.bar.ok = false
-    waitForUpdate(() => {
-      expect(vm.$refs.foo.$refs.bar.$el.tagName).toBe('SPAN')
-      expect(vm.$refs.foo.$refs.bar.$el.className).toBe(`hello`)
-    }).then(done)
-  })
-
-  // #6790
-  it('should not render undefined for empty nested arrays', () => {
-    const vm = new Vue({
-      template: `<div><template v-for="i in emptyArr"></template></div>`,
-      data: { emptyArr: [] }
-    }).$mount()
-    expect(vm.$el.textContent).toBe('')
-  })
-
-  // #6803
-  it('backwards compat with checkbox code generated before 2.4', () => {
-    const spy = jasmine.createSpy()
-    const vm = new Vue({
-      data: {
-        label: 'foobar',
-        name: 'foobar'
-      },
-      computed: {
-        value: {
-          get () {
-            return 1
-          },
-          set: spy
-        }
-      },
-      render (h) {
-        const _vm = this
-        return h('div', {},
-          [h('input', {
-            directives: [{
-              name: 'model',
-              rawName: 'v-model',
-              value: (_vm.value),
-              expression: 'value'
-            }],
-            attrs: {
-              'type': 'radio',
-              'name': _vm.name
-            },
-            domProps: {
-              'value': _vm.label,
-              'checked': _vm._q(_vm.value, _vm.label)
-            },
-            on: {
-              '__c': function ($event) {
-                _vm.value = _vm.label
-              }
-            }
-          })])
-      }
-    }).$mount()
-
-    document.body.appendChild(vm.$el)
-    vm.$el.children[0].click()
-    expect(spy).toHaveBeenCalled()
-  })
-
-  // #7041
-  it('transition children with only deep bindings should be patched on update', done => {
-    const vm = new Vue({
-      template: `
-      <div>
-        <transition>
-          <div :style="style"></div>
-        </transition>
-      </div>
-      `,
-      data: () => ({
-        style: { color: 'red' }
-      })
-    }).$mount()
-    expect(vm.$el.children[0].style.color).toBe('red')
-    vm.style.color = 'green'
-    waitForUpdate(() => {
-      expect(vm.$el.children[0].style.color).toBe('green')
-    }).then(done)
-  })
-
-  // #7294
-  it('should cleanup component inline events on patch when no events are present', done => {
-    const log = jasmine.createSpy()
-    const vm = new Vue({
-      data: { ok: true },
-      template: `
-        <div>
-          <foo v-if="ok" @custom="log"/>
-          <foo v-else/>
-        </div>
-      `,
-      components: {
-        foo: {
-          render () {}
-        }
-      },
-      methods: { log }
-    }).$mount()
-
-    vm.ok = false
-    waitForUpdate(() => {
-      vm.$children[0].$emit('custom')
-      expect(log).not.toHaveBeenCalled()
-    }).then(done)
-  })
-
-  // #6864
-  it('should not special-case boolean attributes for custom elements', () => {
-    Vue.config.ignoredElements = [/^custom-/]
-    const vm = new Vue({
-      template: `<div><custom-foo selected="1"/></div>`
-    }).$mount()
-    expect(vm.$el.querySelector('custom-foo').getAttribute('selected')).toBe('1')
-    Vue.config.ignoredElements = []
-  })
-
-  // #7805
-  it('should not cause duplicate init when components share data object', () => {
-    const Base = {
-      render (h) {
-        return h('div', this.$options.name)
-      }
-    }
-
-    const Foo = {
-      name: 'Foo',
-      extends: Base
-    }
-
-    const Bar = {
-      name: 'Bar',
-      extends: Base
-    }
-
-    // sometimes we do need to tap into these internal hooks (e.g. in vue-router)
-    // so make sure it does work
-    const inlineHookSpy = jasmine.createSpy('inlineInit')
-
-    const vm = new Vue({
-      render (h) {
-        const data = { staticClass: 'text-red', hook: {
-          init: inlineHookSpy
-        }}
-
-        return h('div', [
-          h(Foo, data),
-          h(Bar, data)
-        ])
-      }
-    }).$mount()
-
-    expect(vm.$el.textContent).toBe('FooBar')
-    expect(inlineHookSpy.calls.count()).toBe(2)
-  })
-
-  // #9549
-  it('DOM props set throwing should not break app', done => {
-    const vm = new Vue({
-      data: {
-        n: Infinity
-      },
-      template: `
-        <div>
-          <progress :value="n"/>
-          {{ n }}
-        </div>
-      `
-    }).$mount()
-
-    expect(vm.$el.textContent).toMatch('Infinity')
-    vm.n = 1
-    waitForUpdate(() => {
-      expect(vm.$el.textContent).toMatch('1')
-      expect(vm.$el.textContent).not.toMatch('Infinity')
-    }).then(done)
-  })
-})
diff --git a/1.Vue/test/unit/modules/vdom/patch/element.spec.js b/1.Vue/test/unit/modules/vdom/patch/element.spec.js
deleted file mode 100644
index 09bf3fa..0000000
--- a/1.Vue/test/unit/modules/vdom/patch/element.spec.js
+++ /dev/null
@@ -1,60 +0,0 @@
-import Vue from 'vue'
-import { patch } from 'web/runtime/patch'
-import VNode from 'core/vdom/vnode'
-
-describe('vdom patch: element', () => {
-  it('should create an element', () => {
-    const vnode = new VNode('p', { attrs: { id: '1' }}, [createTextVNode('hello world')])
-    const elm = patch(null, vnode)
-    expect(elm.tagName).toBe('P')
-    expect(elm.outerHTML).toBe('<p id="1">hello world</p>')
-  })
-
-  it('should create an element which having the namespace', () => {
-    const vnode = new VNode('svg', {})
-    vnode.ns = 'svg'
-    const elm = patch(null, vnode)
-    expect(elm.namespaceURI).toBe('http://www.w3.org/2000/svg')
-  })
-
-  const el = document.createElement('unknown')
-  // Android Browser <= 4.2 doesn't use correct class name,
-  // but it doesn't matter because no one's gonna use it as their primary
-  // development browser.
-  if (/HTMLUnknownElement/.test(el.toString())) {
-    it('should warn unknown element', () => {
-      const vnode = new VNode('unknown')
-      patch(null, vnode)
-      expect(`Unknown custom element: <unknown>`).toHaveBeenWarned()
-    })
-  }
-
-  it('should warn unknown element with hyphen', () => {
-    const vnode = new VNode('unknown-foo')
-    patch(null, vnode)
-    expect(`Unknown custom element: <unknown-foo>`).toHaveBeenWarned()
-  })
-
-  it('should create an elements which having text content', () => {
-    const vnode = new VNode('div', {}, [createTextVNode('hello world')])
-    const elm = patch(null, vnode)
-    expect(elm.innerHTML).toBe('hello world')
-  })
-
-  it('should create create an elements which having span and text content', () => {
-    const vnode = new VNode('div', {}, [
-      new VNode('span'),
-      createTextVNode('hello world')
-    ])
-    const elm = patch(null, vnode)
-    expect(elm.childNodes[0].tagName).toBe('SPAN')
-    expect(elm.childNodes[1].textContent).toBe('hello world')
-  })
-
-  it('should create element with scope attribute', () => {
-    const vnode = new VNode('div')
-    vnode.context = new Vue({ _scopeId: 'foo' })
-    const elm = patch(null, vnode)
-    expect(elm.hasAttribute('foo')).toBe(true)
-  })
-})
diff --git a/1.Vue/test/unit/modules/vdom/patch/hooks.spec.js b/1.Vue/test/unit/modules/vdom/patch/hooks.spec.js
deleted file mode 100644
index dbb7ee3..0000000
--- a/1.Vue/test/unit/modules/vdom/patch/hooks.spec.js
+++ /dev/null
@@ -1,321 +0,0 @@
-import { patch } from 'web/runtime/patch'
-import { createPatchFunction } from 'core/vdom/patch'
-import baseModules from 'core/vdom/modules/index'
-import * as nodeOps from 'web/runtime/node-ops'
-import platformModules from 'web/runtime/modules/index'
-import VNode from 'core/vdom/vnode'
-
-const modules = baseModules.concat(platformModules)
-
-describe('vdom patch: hooks', () => {
-  let vnode0
-  beforeEach(() => {
-    vnode0 = new VNode('p', { attrs: { id: '1' }}, [createTextVNode('hello world')])
-    patch(null, vnode0)
-  })
-
-  it('should call `insert` listener after both parents, siblings and children have been inserted', () => {
-    const result = []
-    function insert (vnode) {
-      expect(vnode.elm.children.length).toBe(2)
-      expect(vnode.elm.parentNode.children.length).toBe(3)
-      result.push(vnode)
-    }
-    const vnode1 = new VNode('div', {}, [
-      new VNode('span', {}, undefined, 'first sibling'),
-      new VNode('div', { hook: { insert }}, [
-        new VNode('span', {}, undefined, 'child 1'),
-        new VNode('span', {}, undefined, 'child 2')
-      ]),
-      new VNode('span', {}, undefined, 'can touch me')
-    ])
-    patch(vnode0, vnode1)
-    expect(result.length).toBe(1)
-  })
-
-  it('should call `prepatch` listener', () => {
-    const result = []
-    function prepatch (oldVnode, newVnode) {
-      expect(oldVnode).toEqual(vnode1.children[1])
-      expect(newVnode).toEqual(vnode2.children[1])
-      result.push(newVnode)
-    }
-    const vnode1 = new VNode('div', {}, [
-      new VNode('span', {}, undefined, 'first sibling'),
-      new VNode('div', { hook: { prepatch }}, [
-        new VNode('span', {}, undefined, 'child 1'),
-        new VNode('span', {}, undefined, 'child 2')
-      ])
-    ])
-    const vnode2 = new VNode('div', {}, [
-      new VNode('span', {}, undefined, 'first sibling'),
-      new VNode('div', { hook: { prepatch }}, [
-        new VNode('span', {}, undefined, 'child 1'),
-        new VNode('span', {}, undefined, 'child 2')
-      ])
-    ])
-    patch(vnode0, vnode1)
-    patch(vnode1, vnode2)
-    expect(result.length).toBe(1)
-  })
-
-  it('should call `postpatch` after `prepatch` listener', () => {
-    const pre = []
-    const post = []
-    function prepatch (oldVnode, newVnode) {
-      pre.push(pre)
-    }
-    function postpatch (oldVnode, newVnode) {
-      expect(pre.length).toBe(post.length + 1)
-      post.push(post)
-    }
-    const vnode1 = new VNode('div', {}, [
-      new VNode('span', {}, undefined, 'first sibling'),
-      new VNode('div', { hook: { prepatch, postpatch }}, [
-        new VNode('span', {}, undefined, 'child 1'),
-        new VNode('span', {}, undefined, 'child 2')
-      ])
-    ])
-    const vnode2 = new VNode('div', {}, [
-      new VNode('span', {}, undefined, 'first sibling'),
-      new VNode('div', { hook: { prepatch, postpatch }}, [
-        new VNode('span', {}, undefined, 'child 1'),
-        new VNode('span', {}, undefined, 'child 2')
-      ])
-    ])
-    patch(vnode0, vnode1)
-    patch(vnode1, vnode2)
-    expect(pre.length).toBe(1)
-    expect(post.length).toBe(1)
-  })
-
-  it('should call `update` listener', () => {
-    const result1 = []
-    const result2 = []
-    function cb (result, oldVnode, newVnode) {
-      if (result.length > 1) {
-        expect(result[result.length - 1]).toEqual(oldVnode)
-      }
-      result.push(newVnode)
-    }
-    const vnode1 = new VNode('div', {}, [
-      new VNode('span', {}, undefined, 'first sibling'),
-      new VNode('div', { hook: { update: cb.bind(null, result1) }}, [
-        new VNode('span', {}, undefined, 'child 1'),
-        new VNode('span', { hook: { update: cb.bind(null, result2) }}, undefined, 'child 2')
-      ])
-    ])
-    const vnode2 = new VNode('div', {}, [
-      new VNode('span', {}, undefined, 'first sibling'),
-      new VNode('div', { hook: { update: cb.bind(null, result1) }}, [
-        new VNode('span', {}, undefined, 'child 1'),
-        new VNode('span', { hook: { update: cb.bind(null, result2) }}, undefined, 'child 2')
-      ])
-    ])
-    patch(vnode0, vnode1)
-    patch(vnode1, vnode2)
-    expect(result1.length).toBe(1)
-    expect(result2.length).toBe(1)
-  })
-
-  it('should call `remove` listener', () => {
-    const result = []
-    function remove (vnode, rm) {
-      const parent = vnode.elm.parentNode
-      expect(vnode.elm.children.length).toBe(2)
-      expect(vnode.elm.children.length).toBe(2)
-      result.push(vnode)
-      rm()
-      expect(parent.children.length).toBe(1)
-    }
-    const vnode1 = new VNode('div', {}, [
-      new VNode('span', {}, undefined, 'first sibling'),
-      new VNode('div', { hook: { remove }}, [
-        new VNode('span', {}, undefined, 'child 1'),
-        new VNode('span', {}, undefined, 'child 2')
-      ])
-    ])
-    const vnode2 = new VNode('div', {}, [
-      new VNode('span', {}, undefined, 'first sibling')
-    ])
-    patch(vnode0, vnode1)
-    patch(vnode1, vnode2)
-    expect(result.length).toBe(1)
-  })
-
-  it('should call `init` and `prepatch` listeners on root', () => {
-    let count = 0
-    function init (vnode) { count++ }
-    function prepatch (oldVnode, newVnode) { count++ }
-    const vnode1 = new VNode('div', { hook: { init, prepatch }})
-    patch(vnode0, vnode1)
-    expect(count).toBe(1)
-    const vnode2 = new VNode('span', { hook: { init, prepatch }})
-    patch(vnode1, vnode2)
-    expect(count).toBe(2)
-  })
-
-  it('should remove element when all remove listeners are done', () => {
-    let rm1, rm2, rm3
-    const patch1 = createPatchFunction({
-      nodeOps,
-      modules: modules.concat([
-        { remove (_, rm) { rm1 = rm } },
-        { remove (_, rm) { rm2 = rm } }
-      ])
-    })
-    const vnode1 = new VNode('div', {}, [
-      new VNode('a', { hook: { remove (_, rm) { rm3 = rm } }})
-    ])
-    const vnode2 = new VNode('div', {}, [])
-    let elm = patch1(vnode0, vnode1)
-    expect(elm.children.length).toBe(1)
-    elm = patch1(vnode1, vnode2)
-    expect(elm.children.length).toBe(1)
-    rm1()
-    expect(elm.children.length).toBe(1)
-    rm3()
-    expect(elm.children.length).toBe(1)
-    rm2()
-    expect(elm.children.length).toBe(0)
-  })
-
-  it('should invoke the remove hook on replaced root', () => {
-    const result = []
-    const parent = nodeOps.createElement('div')
-    vnode0 = nodeOps.createElement('div')
-    parent.appendChild(vnode0)
-    function remove (vnode, rm) {
-      result.push(vnode)
-      rm()
-    }
-    const vnode1 = new VNode('div', { hook: { remove }}, [
-      new VNode('b', {}, undefined, 'child 1'),
-      new VNode('i', {}, undefined, 'child 2')
-    ])
-    const vnode2 = new VNode('span', {}, [
-      new VNode('b', {}, undefined, 'child 1'),
-      new VNode('i', {}, undefined, 'child 2')
-    ])
-    patch(vnode0, vnode1)
-    patch(vnode1, vnode2)
-    expect(result.length).toBe(1)
-  })
-
-  it('should invoke global `destroy` hook for all removed children', () => {
-    const result = []
-    function destroy (vnode) { result.push(vnode) }
-    const vnode1 = new VNode('div', {}, [
-      new VNode('span', {}, undefined, 'first sibling'),
-      new VNode('div', {}, [
-        new VNode('span', { hook: { destroy }}, undefined, 'child 1'),
-        new VNode('span', {}, undefined, 'child 2')
-      ])
-    ])
-    const vnode2 = new VNode('div')
-    patch(vnode0, vnode1)
-    patch(vnode1, vnode2)
-    expect(result.length).toBe(1)
-  })
-
-  it('should handle text vnodes with `undefined` `data` property', () => {
-    const vnode1 = new VNode('div', {}, [createTextVNode(' ')])
-    const vnode2 = new VNode('div', {}, [])
-    patch(vnode0, vnode1)
-    patch(vnode1, vnode2)
-  })
-
-  it('should invoke `destroy` module hook for all removed children', () => {
-    let created = 0
-    let destroyed = 0
-    const patch1 = createPatchFunction({
-      nodeOps,
-      modules: modules.concat([
-        { create () { created++ } },
-        { destroy () { destroyed++ } }
-      ])
-    })
-    const vnode1 = new VNode('div', {}, [
-      new VNode('span', {}, undefined, 'first sibling'),
-      new VNode('div', {}, [
-        new VNode('span', {}, undefined, 'child 1'),
-        new VNode('span', {}, undefined, 'child 2')
-      ])
-    ])
-    const vnode2 = new VNode('div', {})
-    patch1(vnode0, vnode1)
-    expect(destroyed).toBe(1) // should invoke for replaced root nodes too
-    patch1(vnode1, vnode2)
-    expect(created).toBe(5)
-    expect(destroyed).toBe(5)
-  })
-
-  it('should not invoke `create` and `remove` module hook for text nodes', () => {
-    let created = 0
-    let removed = 0
-    const patch1 = createPatchFunction({
-      nodeOps,
-      modules: modules.concat([
-        { create () { created++ } },
-        { remove () { removed++ } }
-      ])
-    })
-    const vnode1 = new VNode('div', {}, [
-      new VNode('span', {}, undefined, 'first child'),
-      createTextVNode(''),
-      new VNode('span', {}, undefined, 'third child')
-    ])
-    const vnode2 = new VNode('div', {})
-    patch1(vnode0, vnode1)
-    patch1(vnode1, vnode2)
-    expect(created).toBe(3)
-    expect(removed).toBe(2)
-  })
-
-  it('should not invoke `destroy` module hook for text nodes', () => {
-    let created = 0
-    let destroyed = 0
-    const patch1 = createPatchFunction({
-      nodeOps,
-      modules: modules.concat([
-        { create () { created++ } },
-        { destroy () { destroyed++ } }
-      ])
-    })
-    const vnode1 = new VNode('div', {}, [
-      new VNode('span', {}, undefined, 'first sibling'),
-      new VNode('div', {}, [
-        new VNode('span', {}, undefined, 'child 1'),
-        new VNode('span', {}, [
-          createTextVNode('text1'),
-          createTextVNode('text2')
-        ])
-      ])
-    ])
-    const vnode2 = new VNode('div', {})
-    patch1(vnode0, vnode1)
-    expect(destroyed).toBe(1) // should invoke for replaced root nodes too
-    patch1(vnode1, vnode2)
-    expect(created).toBe(5)
-    expect(destroyed).toBe(5)
-  })
-
-  it('should call `create` listener before inserted into parent but after children', () => {
-    const result = []
-    function create (empty, vnode) {
-      expect(vnode.elm.children.length).toBe(2)
-      expect(vnode.elm.parentNode).toBe(null)
-      result.push(vnode)
-    }
-    const vnode1 = new VNode('div', {}, [
-      new VNode('span', {}, undefined, 'first sibling'),
-      new VNode('div', { hook: { create }}, [
-        new VNode('span', {}, undefined, 'child 1'),
-        new VNode('span', {}, undefined, 'child 2')
-      ]),
-      new VNode('span', {}, undefined, 'can\'t touch me')
-    ])
-    patch(vnode0, vnode1)
-    expect(result.length).toBe(1)
-  })
-})
diff --git a/1.Vue/test/unit/modules/vdom/patch/hydration.spec.js b/1.Vue/test/unit/modules/vdom/patch/hydration.spec.js
deleted file mode 100644
index 930ad47..0000000
--- a/1.Vue/test/unit/modules/vdom/patch/hydration.spec.js
+++ /dev/null
@@ -1,391 +0,0 @@
-import Vue from 'vue'
-import VNode from 'core/vdom/vnode'
-import { patch } from 'web/runtime/patch'
-import { SSR_ATTR } from 'shared/constants'
-
-function createMockSSRDOM (innerHTML) {
-  const dom = document.createElement('div')
-  dom.setAttribute(SSR_ATTR, 'true')
-  dom.innerHTML = innerHTML
-  return dom
-}
-
-describe('vdom patch: hydration', () => {
-  let vnode0
-  beforeEach(() => {
-    vnode0 = new VNode('p', { attrs: { id: '1' }}, [createTextVNode('hello world')])
-    patch(null, vnode0)
-  })
-
-  it('should hydrate elements when server-rendered DOM tree is same as virtual DOM tree', () => {
-    const result = []
-    function init (vnode) { result.push(vnode) }
-    function createServerRenderedDOM () {
-      const root = document.createElement('div')
-      root.setAttribute(SSR_ATTR, 'true')
-      const span = document.createElement('span')
-      root.appendChild(span)
-      const div = document.createElement('div')
-      const child1 = document.createElement('span')
-      const child2 = document.createElement('span')
-      child1.textContent = 'hi'
-      child2.textContent = 'ho'
-      div.appendChild(child1)
-      div.appendChild(child2)
-      root.appendChild(div)
-      return root
-    }
-    const node0 = createServerRenderedDOM()
-    const vnode1 = new VNode('div', {}, [
-      new VNode('span', {}),
-      new VNode('div', { hook: { init }}, [
-        new VNode('span', {}, [new VNode(undefined, undefined, undefined, 'hi')]),
-        new VNode('span', {}, [new VNode(undefined, undefined, undefined, 'ho')])
-      ])
-    ])
-    patch(node0, vnode1)
-    expect(result.length).toBe(1)
-
-    function traverseAndAssert (vnode, element) {
-      expect(vnode.elm).toBe(element)
-      if (vnode.children) {
-        vnode.children.forEach((node, i) => {
-          traverseAndAssert(node, element.childNodes[i])
-        })
-      }
-    }
-    // ensure vnodes are correctly associated with actual DOM
-    traverseAndAssert(vnode1, node0)
-
-    // check update
-    const vnode2 = new VNode('div', { attrs: { id: 'foo' }}, [
-      new VNode('span', { attrs: { id: 'bar' }}),
-      new VNode('div', { hook: { init }}, [
-        new VNode('span', {}),
-        new VNode('span', {})
-      ])
-    ])
-    patch(vnode1, vnode2)
-    expect(node0.id).toBe('foo')
-    expect(node0.children[0].id).toBe('bar')
-  })
-
-  it('should warn message that virtual DOM tree is not matching when hydrate element', () => {
-    function createServerRenderedDOM () {
-      const root = document.createElement('div')
-      root.setAttribute(SSR_ATTR, 'true')
-      const span = document.createElement('span')
-      root.appendChild(span)
-      const div = document.createElement('div')
-      const child1 = document.createElement('span')
-      div.appendChild(child1)
-      root.appendChild(div)
-      return root
-    }
-    const node0 = createServerRenderedDOM()
-    const vnode1 = new VNode('div', {}, [
-      new VNode('span', {}),
-      new VNode('div', {}, [
-        new VNode('span', {}),
-        new VNode('span', {})
-      ])
-    ])
-    patch(node0, vnode1)
-    expect('The client-side rendered virtual DOM tree is not matching').toHaveBeenWarned()
-  })
-
-  // component hydration is better off with a more e2e approach
-  it('should hydrate components when server-rendered DOM tree is same as virtual DOM tree', done => {
-    const dom = createMockSSRDOM('<span>foo</span><div class="b a"><span>foo qux</span></div><!---->')
-    const originalNode1 = dom.children[0]
-    const originalNode2 = dom.children[1]
-
-    const vm = new Vue({
-      template: '<div><span>{{msg}}</span><test class="a" :msg="msg"></test><p v-if="ok"></p></div>',
-      data: {
-        msg: 'foo',
-        ok: false
-      },
-      components: {
-        test: {
-          props: ['msg'],
-          data () {
-            return { a: 'qux' }
-          },
-          template: '<div class="b"><span>{{msg}} {{a}}</span></div>'
-        }
-      }
-    })
-
-    expect(() => { vm.$mount(dom) }).not.toThrow()
-    expect('not matching server-rendered content').not.toHaveBeenWarned()
-    expect(vm.$el).toBe(dom)
-    expect(vm.$children[0].$el).toBe(originalNode2)
-    expect(vm.$el.children[0]).toBe(originalNode1)
-    expect(vm.$el.children[1]).toBe(originalNode2)
-    vm.msg = 'bar'
-    waitForUpdate(() => {
-      expect(vm.$el.innerHTML).toBe('<span>bar</span><div class="b a"><span>bar qux</span></div><!---->')
-      vm.$children[0].a = 'ququx'
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<span>bar</span><div class="b a"><span>bar ququx</span></div><!---->')
-      vm.ok = true
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<span>bar</span><div class="b a"><span>bar ququx</span></div><p></p>')
-    }).then(done)
-  })
-
-  it('should warn failed hydration for non-matching DOM in child component', () => {
-    const dom = createMockSSRDOM('<div><span></span></div>')
-
-    new Vue({
-      template: '<div><test></test></div>',
-      components: {
-        test: {
-          template: '<div><a></a></div>'
-        }
-      }
-    }).$mount(dom)
-
-    expect('not matching server-rendered content').toHaveBeenWarned()
-  })
-
-  it('should warn failed hydration when component is not properly registered', () => {
-    const dom = createMockSSRDOM('<div><foo></foo></div>')
-
-    new Vue({
-      template: '<div><foo></foo></div>'
-    }).$mount(dom)
-
-    expect('not matching server-rendered content').toHaveBeenWarned()
-    expect('Unknown custom element: <foo>').toHaveBeenWarned()
-  })
-
-  it('should overwrite textNodes in the correct position but with mismatching text without warning', () => {
-    const dom = createMockSSRDOM('<div><span>foo</span></div>')
-
-    new Vue({
-      template: '<div><test></test></div>',
-      components: {
-        test: {
-          data () {
-            return { a: 'qux' }
-          },
-          template: '<div><span>{{a}}</span></div>'
-        }
-      }
-    }).$mount(dom)
-
-    expect('not matching server-rendered content').not.toHaveBeenWarned()
-    expect(dom.querySelector('span').textContent).toBe('qux')
-  })
-
-  it('should pick up elements with no children and populate without warning', done => {
-    const dom = createMockSSRDOM('<div><span></span></div>')
-    const span = dom.querySelector('span')
-
-    const vm = new Vue({
-      template: '<div><test></test></div>',
-      components: {
-        test: {
-          data () {
-            return { a: 'qux' }
-          },
-          template: '<div><span>{{a}}</span></div>'
-        }
-      }
-    }).$mount(dom)
-
-    expect('not matching server-rendered content').not.toHaveBeenWarned()
-    expect(span).toBe(vm.$el.querySelector('span'))
-    expect(vm.$el.innerHTML).toBe('<div><span>qux</span></div>')
-
-    vm.$children[0].a = 'foo'
-    waitForUpdate(() => {
-      expect(vm.$el.innerHTML).toBe('<div><span>foo</span></div>')
-    }).then(done)
-  })
-
-  it('should hydrate async component', done => {
-    const dom = createMockSSRDOM('<span>foo</span>')
-    const span = dom.querySelector('span')
-
-    const Foo = resolve => setTimeout(() => {
-      resolve({
-        data: () => ({ msg: 'foo' }),
-        template: `<span>{{ msg }}</span>`
-      })
-    }, 0)
-
-    const vm = new Vue({
-      template: '<div><foo ref="foo" /></div>',
-      components: { Foo }
-    }).$mount(dom)
-
-    expect('not matching server-rendered content').not.toHaveBeenWarned()
-    expect(dom.innerHTML).toBe('<span>foo</span>')
-    expect(vm.$refs.foo).toBeUndefined()
-
-    setTimeout(() => {
-      expect(dom.innerHTML).toBe('<span>foo</span>')
-      expect(vm.$refs.foo).not.toBeUndefined()
-      vm.$refs.foo.msg = 'bar'
-      waitForUpdate(() => {
-        expect(dom.innerHTML).toBe('<span>bar</span>')
-        expect(dom.querySelector('span')).toBe(span)
-      }).then(done)
-    }, 50)
-  })
-
-  it('should hydrate async component without showing loading', done => {
-    const dom = createMockSSRDOM('<span>foo</span>')
-    const span = dom.querySelector('span')
-
-    const Foo = () => ({
-      component: new Promise(resolve => {
-        setTimeout(() => {
-          resolve({
-            data: () => ({ msg: 'foo' }),
-            template: `<span>{{ msg }}</span>`
-          })
-        }, 10)
-      }),
-      delay: 1,
-      loading: {
-        render: h => h('span', 'loading')
-      }
-    })
-
-    const vm = new Vue({
-      template: '<div><foo ref="foo" /></div>',
-      components: { Foo }
-    }).$mount(dom)
-
-    expect('not matching server-rendered content').not.toHaveBeenWarned()
-    expect(dom.innerHTML).toBe('<span>foo</span>')
-    expect(vm.$refs.foo).toBeUndefined()
-
-    setTimeout(() => {
-      expect(dom.innerHTML).toBe('<span>foo</span>')
-    }, 2)
-
-    setTimeout(() => {
-      expect(dom.innerHTML).toBe('<span>foo</span>')
-      expect(vm.$refs.foo).not.toBeUndefined()
-      vm.$refs.foo.msg = 'bar'
-      waitForUpdate(() => {
-        expect(dom.innerHTML).toBe('<span>bar</span>')
-        expect(dom.querySelector('span')).toBe(span)
-      }).then(done)
-    }, 50)
-  })
-
-  it('should hydrate async component by replacing DOM if error occurs', done => {
-    const dom = createMockSSRDOM('<span>foo</span>')
-
-    const Foo = () => ({
-      component: new Promise((resolve, reject) => {
-        setTimeout(() => {
-          reject('something went wrong')
-        }, 10)
-      }),
-      error: {
-        render: h => h('span', 'error')
-      }
-    })
-
-    new Vue({
-      template: '<div><foo ref="foo" /></div>',
-      components: { Foo }
-    }).$mount(dom)
-
-    expect('not matching server-rendered content').not.toHaveBeenWarned()
-    expect(dom.innerHTML).toBe('<span>foo</span>')
-
-    setTimeout(() => {
-      expect('Failed to resolve async').toHaveBeenWarned()
-      expect(dom.innerHTML).toBe('<span>error</span>')
-      done()
-    }, 50)
-  })
-
-  it('should hydrate v-html with children', () => {
-    const dom = createMockSSRDOM('<span>foo</span>')
-
-    new Vue({
-      data: {
-        html: `<span>foo</span>`
-      },
-      template: `<div v-html="html">hello</div>`
-    }).$mount(dom)
-
-    expect('not matching server-rendered content').not.toHaveBeenWarned()
-  })
-
-  it('should warn mismatching v-html', () => {
-    const dom = createMockSSRDOM('<span>bar</span>')
-
-    new Vue({
-      data: {
-        html: `<span>foo</span>`
-      },
-      template: `<div v-html="html">hello</div>`
-    }).$mount(dom)
-
-    expect('not matching server-rendered content').toHaveBeenWarned()
-  })
-
-  it('should hydrate with adjacent text nodes from array children (e.g. slots)', () => {
-    const dom = createMockSSRDOM('<div>foo</div> hello')
-
-    new Vue({
-      template: `<test>hello</test>`,
-      components: {
-        test: {
-          template: `
-            <div>
-              <div>foo</div>
-              <slot/>
-            </div>
-          `
-        }
-      }
-    }).$mount(dom)
-    expect('not matching server-rendered content').not.toHaveBeenWarned()
-  })
-
-  // #7063
-  it('should properly initialize dynamic style bindings for future updates', done => {
-    const dom = createMockSSRDOM('<div style="padding-left:0px"></div>')
-
-    const vm = new Vue({
-      data: {
-        style: { paddingLeft: '0px' }
-      },
-      template: `<div><div :style="style"></div></div>`
-    }).$mount(dom)
-
-    // should update
-    vm.style.paddingLeft = '100px'
-    waitForUpdate(() => {
-      expect(dom.children[0].style.paddingLeft).toBe('100px')
-    }).then(done)
-  })
-
-  it('should properly initialize dynamic class bindings for future updates', done => {
-    const dom = createMockSSRDOM('<div class="foo bar"></div>')
-
-    const vm = new Vue({
-      data: {
-        cls: [{ foo: true }, 'bar']
-      },
-      template: `<div><div :class="cls"></div></div>`
-    }).$mount(dom)
-
-    // should update
-    vm.cls[0].foo = false
-    waitForUpdate(() => {
-      expect(dom.children[0].className).toBe('bar')
-    }).then(done)
-  })
-})
diff --git a/1.Vue/test/weex/.eslintrc b/1.Vue/test/weex/.eslintrc
deleted file mode 100644
index dab5d0e..0000000
--- a/1.Vue/test/weex/.eslintrc
+++ /dev/null
@@ -1,9 +0,0 @@
-{
-  "env": {
-    "jasmine": true
-  },
-  "plugins": ["jasmine"],
-  "rules": {
-    "jasmine/no-focused-tests": 2
-  }
-}
diff --git a/1.Vue/test/weex/cases/cases.spec.js b/1.Vue/test/weex/cases/cases.spec.js
deleted file mode 100644
index f02ea21..0000000
--- a/1.Vue/test/weex/cases/cases.spec.js
+++ /dev/null
@@ -1,238 +0,0 @@
-import {
-  readFile,
-  readObject,
-  compileVue,
-  compileWithDeps,
-  createInstance,
-  addTaskHook,
-  resetTaskHook,
-  getRoot,
-  getEvents,
-  fireEvent
-} from '../helpers'
-
-// Create one-off render test case
-function createRenderTestCase (name) {
-  const source = readFile(`${name}.vue`)
-  const target = readObject(`${name}.vdom.js`)
-  return done => {
-    compileVue(source).then(code => {
-      const id = String(Date.now() * Math.random())
-      const instance = createInstance(id, code)
-      setTimeout(() => {
-        expect(getRoot(instance)).toEqual(target)
-        instance.$destroy()
-        done()
-      }, 50)
-    }).catch(done.fail)
-  }
-}
-
-// Create event test case, will trigger the first bind event
-function createEventTestCase (name) {
-  const source = readFile(`${name}.vue`)
-  const before = readObject(`${name}.before.vdom.js`)
-  const after = readObject(`${name}.after.vdom.js`)
-  return done => {
-    compileVue(source).then(code => {
-      const id = String(Date.now() * Math.random())
-      const instance = createInstance(id, code)
-      setTimeout(() => {
-        expect(getRoot(instance)).toEqual(before)
-        const event = getEvents(instance)[0]
-        fireEvent(instance, event.ref, event.type, {})
-        setTimeout(() => {
-          expect(getRoot(instance)).toEqual(after)
-          instance.$destroy()
-          done()
-        }, 50)
-      }, 50)
-    }).catch(done.fail)
-  }
-}
-
-describe('Usage', () => {
-  describe('render', () => {
-    it('sample', createRenderTestCase('render/sample'))
-    it('class', createRenderTestCase('render/class'))
-  })
-
-  describe('event', () => {
-    it('click', createEventTestCase('event/click'))
-  })
-
-  describe('recycle-list', () => {
-    it('text node', createRenderTestCase('recycle-list/text-node'))
-    it('attributes', createRenderTestCase('recycle-list/attrs'))
-    // it('class name', createRenderTestCase('recycle-list/classname'))
-    it('inline style', createRenderTestCase('recycle-list/inline-style'))
-    it('v-if', createRenderTestCase('recycle-list/v-if'))
-    it('v-else', createRenderTestCase('recycle-list/v-else'))
-    it('v-else-if', createRenderTestCase('recycle-list/v-else-if'))
-    it('v-for', createRenderTestCase('recycle-list/v-for'))
-    it('v-for-iterator', createRenderTestCase('recycle-list/v-for-iterator'))
-    it('v-on', createRenderTestCase('recycle-list/v-on'))
-    it('v-on-inline', createRenderTestCase('recycle-list/v-on-inline'))
-    it('v-once', createRenderTestCase('recycle-list/v-once'))
-
-    it('stateless component', done => {
-      compileWithDeps('recycle-list/components/stateless.vue', [{
-        name: 'banner',
-        path: 'recycle-list/components/banner.vue'
-      }]).then(code => {
-        const id = String(Date.now() * Math.random())
-        const instance = createInstance(id, code)
-        setTimeout(() => {
-          const target = readObject('recycle-list/components/stateless.vdom.js')
-          expect(getRoot(instance)).toEqual(target)
-          instance.$destroy()
-          done()
-        }, 50)
-      }).catch(done.fail)
-    })
-
-    it('stateless component with props', done => {
-      compileWithDeps('recycle-list/components/stateless-with-props.vue', [{
-        name: 'poster',
-        path: 'recycle-list/components/poster.vue'
-      }]).then(code => {
-        const id = String(Date.now() * Math.random())
-        const instance = createInstance(id, code)
-        setTimeout(() => {
-          const target = readObject('recycle-list/components/stateless-with-props.vdom.js')
-          expect(getRoot(instance)).toEqual(target)
-          instance.$destroy()
-          done()
-        }, 50)
-      }).catch(done.fail)
-    })
-
-    it('multi stateless components', done => {
-      compileWithDeps('recycle-list/components/stateless-multi-components.vue', [{
-        name: 'banner',
-        path: 'recycle-list/components/banner.vue'
-      }, {
-        name: 'poster',
-        path: 'recycle-list/components/poster.vue'
-      }, {
-        name: 'footer',
-        path: 'recycle-list/components/footer.vue'
-      }]).then(code => {
-        const id = String(Date.now() * Math.random())
-        const instance = createInstance(id, code)
-        setTimeout(() => {
-          const target = readObject('recycle-list/components/stateless-multi-components.vdom.js')
-          expect(getRoot(instance)).toEqual(target)
-          instance.$destroy()
-          done()
-        }, 50)
-      }).catch(done.fail)
-    })
-
-    it('stateful component', done => {
-      const tasks = []
-      addTaskHook((_, task) => tasks.push(task))
-      compileWithDeps('recycle-list/components/stateful.vue', [{
-        name: 'counter',
-        path: 'recycle-list/components/counter.vue'
-      }]).then(code => {
-        const id = String(Date.now() * Math.random())
-        const instance = createInstance(id, code)
-        // expect(tasks.length).toEqual(3)
-        setTimeout(() => {
-          // check the render results
-          const target = readObject('recycle-list/components/stateful.vdom.js')
-          expect(getRoot(instance)).toEqual(target)
-          tasks.length = 0
-
-          // // trigger component hooks
-          // instance.$triggerHook(
-          //   2, // cid of the virtual component template
-          //   'create', // lifecycle hook name
-
-          //   // arguments for the callback
-          //   [
-          //     'x-1', // componentId of the virtual component
-          //     { start: 3 } // propsData of the virtual component
-          //   ]
-          // )
-          // instance.$triggerHook(2, 'create', ['x-2', { start: 11 }])
-
-          // // the state (_data) of the virtual component should be sent to native
-          // expect(tasks.length).toEqual(2)
-          // expect(tasks[0].method).toEqual('updateComponentData')
-          // expect(tasks[0].args).toEqual(['x-1', { count: 6 }, ''])
-          // expect(tasks[1].method).toEqual('updateComponentData')
-          // expect(tasks[1].args).toEqual(['x-2', { count: 22 }, ''])
-
-          // instance.$triggerHook('x-1', 'attach')
-          // instance.$triggerHook('x-2', 'attach')
-          // tasks.length = 0
-
-          // // simulate a click event
-          // // the event will be caught by the virtual component template and
-          // // should be dispatched to virtual component according to the componentId
-          // const event = getEvents(instance)[0]
-          // fireEvent(instance, event.ref, 'click', { componentId: 'x-1' })
-          setTimeout(() => {
-            // expect(tasks.length).toEqual(1)
-            // expect(tasks[0].method).toEqual('updateComponentData')
-            // expect(tasks[0].args).toEqual([{ count: 7 }])
-            instance.$destroy()
-            resetTaskHook()
-            done()
-          })
-        }, 50)
-      }).catch(done.fail)
-    })
-
-    // it('component lifecycle', done => {
-    //   global.__lifecycles = []
-    //   compileWithDeps('recycle-list/components/stateful-lifecycle.vue', [{
-    //     name: 'lifecycle',
-    //     path: 'recycle-list/components/lifecycle.vue'
-    //   }]).then(code => {
-    //     const id = String(Date.now() * Math.random())
-    //     const instance = createInstance(id, code)
-    //     setTimeout(() => {
-    //       const target = readObject('recycle-list/components/stateful-lifecycle.vdom.js')
-    //       expect(getRoot(instance)).toEqual(target)
-
-    //       instance.$triggerHook(2, 'create', ['y-1'])
-    //       instance.$triggerHook('y-1', 'attach')
-    //       instance.$triggerHook('y-1', 'detach')
-    //       expect(global.__lifecycles).toEqual([
-    //         'beforeCreate undefined',
-    //         'created 0',
-    //         'beforeMount 1',
-    //         'mounted 1',
-    //         'beforeUpdate 2',
-    //         'updated 2',
-    //         'beforeDestroy 2',
-    //         'destroyed 2'
-    //       ])
-
-    //       delete global.__lifecycles
-    //       instance.$destroy()
-    //       done()
-    //     }, 50)
-    //   }).catch(done.fail)
-    // })
-
-    it('stateful component with v-model', done => {
-      compileWithDeps('recycle-list/components/stateful-v-model.vue', [{
-        name: 'editor',
-        path: 'recycle-list/components/editor.vue'
-      }]).then(code => {
-        const id = String(Date.now() * Math.random())
-        const instance = createInstance(id, code)
-        setTimeout(() => {
-          const target = readObject('recycle-list/components/stateful-v-model.vdom.js')
-          expect(getRoot(instance)).toEqual(target)
-          instance.$destroy()
-          done()
-        }, 50)
-      }).catch(done.fail)
-    })
-  })
-})
diff --git a/1.Vue/test/weex/cases/event/click.after.vdom.js b/1.Vue/test/weex/cases/event/click.after.vdom.js
deleted file mode 100644
index eab1a36..0000000
--- a/1.Vue/test/weex/cases/event/click.after.vdom.js
+++ /dev/null
@@ -1,10 +0,0 @@
-({
-  type: 'div',
-  event: ['click'],
-  children: [{
-    type: 'text',
-    attr: {
-      value: '43'
-    }
-  }]
-})
diff --git a/1.Vue/test/weex/cases/event/click.before.vdom.js b/1.Vue/test/weex/cases/event/click.before.vdom.js
deleted file mode 100644
index de278b3..0000000
--- a/1.Vue/test/weex/cases/event/click.before.vdom.js
+++ /dev/null
@@ -1,10 +0,0 @@
-({
-  type: 'div',
-  event: ['click'],
-  children: [{
-    type: 'text',
-    attr: {
-      value: '42'
-    }
-  }]
-})
diff --git a/1.Vue/test/weex/cases/event/click.vue b/1.Vue/test/weex/cases/event/click.vue
deleted file mode 100644
index 508782c..0000000
--- a/1.Vue/test/weex/cases/event/click.vue
+++ /dev/null
@@ -1,20 +0,0 @@
-<template>
-  <div @click="inc">
-    <text>{{count}}</text>
-  </div>
-</template>
-
-<script>
-  module.exports = {
-    data () {
-      return {
-        count: 42
-      }
-    },
-    methods: {
-      inc () {
-        this.count++
-      }
-    }
-  }
-</script>
diff --git a/1.Vue/test/weex/cases/recycle-list/attrs.vdom.js b/1.Vue/test/weex/cases/recycle-list/attrs.vdom.js
deleted file mode 100644
index ccce367..0000000
--- a/1.Vue/test/weex/cases/recycle-list/attrs.vdom.js
+++ /dev/null
@@ -1,34 +0,0 @@
-({
-  type: 'recycle-list',
-  attr: {
-    append: 'tree',
-    listData: [
-      { type: 'A', count: 1, source: 'http://whatever.com/x.png' },
-      { type: 'A', count: 2, source: 'http://whatever.com/y.png' },
-      { type: 'A', count: 3, source: 'http://whatever.com/z.png' }
-    ],
-    switch: 'type',
-    alias: 'item'
-  },
-  children: [{
-    type: 'cell-slot',
-    attr: { append: 'tree', case: 'A' },
-    children: [{
-      type: 'image',
-      attr: {
-        resize: 'cover',
-        src: {
-          '@binding': 'item.source'
-        }
-      }
-    }, {
-      type: 'text',
-      attr: {
-        lines: '3',
-        count: {
-          '@binding': 'item.count'
-        }
-      }
-    }]
-  }]
-})
diff --git a/1.Vue/test/weex/cases/recycle-list/attrs.vue b/1.Vue/test/weex/cases/recycle-list/attrs.vue
deleted file mode 100644
index 1e2d031..0000000
--- a/1.Vue/test/weex/cases/recycle-list/attrs.vue
+++ /dev/null
@@ -1,23 +0,0 @@
-<template>
-  <recycle-list for="item in longList" switch="type">
-    <cell-slot case="A">
-      <image resize="cover" :src="item.source">
-      <text lines="3" v-bind:count="item.count"></text>
-    </cell-slot>
-  </recycle-list>
-</template>
-
-<script>
-  module.exports = {
-    data () {
-      return {
-        longList: [
-          { type: 'A', count: 1, source: 'http://whatever.com/x.png' },
-          { type: 'A', count: 2, source: 'http://whatever.com/y.png' },
-          { type: 'A', count: 3, source: 'http://whatever.com/z.png' }
-        ]
-      }
-    }
-  }
-</script>
-
diff --git a/1.Vue/test/weex/cases/recycle-list/classname.vdom.js b/1.Vue/test/weex/cases/recycle-list/classname.vdom.js
deleted file mode 100644
index e9280e0..0000000
--- a/1.Vue/test/weex/cases/recycle-list/classname.vdom.js
+++ /dev/null
@@ -1,27 +0,0 @@
-({
-  type: 'recycle-list',
-  attr: {
-    append: 'tree',
-    listData: [
-      { type: 'A', color: 'red' },
-      { type: 'A', color: 'blue' }
-    ],
-    switch: 'type',
-    alias: 'item'
-  },
-  children: [{
-    type: 'cell-slot',
-    attr: { append: 'tree', case: 'A' },
-    style: {
-      backgroundColor: '#FF6600'
-    },
-    children: [{
-      type: 'text',
-      attr: {
-        // not supported yet
-        // classList: ['text', { '@binding': 'item.color' }],
-        value: 'content'
-      }
-    }]
-  }]
-})
diff --git a/1.Vue/test/weex/cases/recycle-list/classname.vue b/1.Vue/test/weex/cases/recycle-list/classname.vue
deleted file mode 100644
index beca441..0000000
--- a/1.Vue/test/weex/cases/recycle-list/classname.vue
+++ /dev/null
@@ -1,37 +0,0 @@
-<template>
-  <recycle-list for="item in longList" switch="type">
-    <cell-slot case="A" class="cell">
-      <text :class="['text', item.color]">content</text>
-    </cell-slot>
-  </recycle-list>
-</template>
-
-<style scoped>
-  .cell {
-    background-color: #FF6600;
-  }
-  .text {
-    font-size: 100px;
-    text-align: center;
-  }
-  .red {
-    color: #FF0000;
-  }
-  .blue {
-    color: #0000FF;
-  }
-</style>
-
-<script>
-  module.exports = {
-    data () {
-      return {
-        longList: [
-          { type: 'A', color: 'red' },
-          { type: 'A', color: 'blue' }
-        ]
-      }
-    }
-  }
-</script>
-
diff --git a/1.Vue/test/weex/cases/recycle-list/components/banner.vue b/1.Vue/test/weex/cases/recycle-list/components/banner.vue
deleted file mode 100644
index a6c2f75..0000000
--- a/1.Vue/test/weex/cases/recycle-list/components/banner.vue
+++ /dev/null
@@ -1,19 +0,0 @@
-<template recyclable="true">
-  <div class="banner">
-    <text class="title">BANNER</text>
-  </div>
-</template>
-
-<style scoped>
-  .banner {
-    height: 120px;
-    justify-content: center;
-    align-items: center;
-    background-color: rgb(162, 217, 192);
-  }
-  .title {
-    font-weight: bold;
-    color: #41B883;
-    font-size: 60px;
-  }
-</style>
diff --git a/1.Vue/test/weex/cases/recycle-list/components/counter.vue b/1.Vue/test/weex/cases/recycle-list/components/counter.vue
deleted file mode 100644
index 79b8189..0000000
--- a/1.Vue/test/weex/cases/recycle-list/components/counter.vue
+++ /dev/null
@@ -1,36 +0,0 @@
-<template recyclable="true">
-  <div>
-    <text class="output">{{count}}</text>
-    <text class="button" @click="inc">+</text>
-  </div>
-</template>
-
-<script>
-  module.exports = {
-    props: ['start'],
-    data () {
-      return {
-        count: parseInt(this.start, 10) * 2 || 42
-      }
-    },
-    methods: {
-      inc () {
-        this.count++
-      }
-    }
-  }
-</script>
-
-<style scoped>
-  .output {
-    font-size: 150px;
-    text-align: center;
-  }
-  .button {
-    font-size: 100px;
-    text-align: center;
-    border-width: 2px;
-    border-color: #DDD;
-    background-color: #F5F5F5;
-  }
-</style>
diff --git a/1.Vue/test/weex/cases/recycle-list/components/editor.vue b/1.Vue/test/weex/cases/recycle-list/components/editor.vue
deleted file mode 100644
index 9ab63e7..0000000
--- a/1.Vue/test/weex/cases/recycle-list/components/editor.vue
+++ /dev/null
@@ -1,31 +0,0 @@
-<template recyclable="true">
-  <div>
-    <text class="output">{{output}}</text>
-    <input class="input" type="text" v-model="output" />
-  </div>
-</template>
-
-<script>
-  module.exports = {
-    props: ['message'],
-    data () {
-      return {
-        output: this.message || ''
-      }
-    }
-  }
-</script>
-
-<style scoped>
-  .output {
-    height: 80px;
-    font-size: 60px;
-    color: #41B883;
-  }
-  .input {
-    font-size: 50px;
-    color: #666666;
-    border-width: 2px;
-    border-color: #41B883;
-  }
-</style>
diff --git a/1.Vue/test/weex/cases/recycle-list/components/footer.vue b/1.Vue/test/weex/cases/recycle-list/components/footer.vue
deleted file mode 100644
index b3fe0c8..0000000
--- a/1.Vue/test/weex/cases/recycle-list/components/footer.vue
+++ /dev/null
@@ -1,18 +0,0 @@
-<template recyclable="true">
-  <div class="footer">
-    <text class="copyright">All rights reserved.</text>
-  </div>
-</template>
-
-<style scoped>
-  .footer {
-    height: 80px;
-    justify-content: center;
-    background-color: #EEEEEE;
-  }
-  .copyright {
-    color: #AAAAAA;
-    font-size: 32px;
-    text-align: center;
-  }
-</style>
diff --git a/1.Vue/test/weex/cases/recycle-list/components/lifecycle.vue b/1.Vue/test/weex/cases/recycle-list/components/lifecycle.vue
deleted file mode 100644
index 03ee65a..0000000
--- a/1.Vue/test/weex/cases/recycle-list/components/lifecycle.vue
+++ /dev/null
@@ -1,39 +0,0 @@
-<template recyclable="true">
-  <div>
-    <text>{{number}}</text>
-  </div>
-</template>
-
-<script>
-  module.exports = {
-    data () {
-      return { number: 0 }
-    },
-    beforeCreate () {
-      try { __lifecycles.push('beforeCreate ' + this.number) } catch (e) {}
-    },
-    created () {
-      try { __lifecycles.push('created ' + this.number) } catch (e) {}
-      this.number++
-    },
-    beforeMount () {
-      try { __lifecycles.push('beforeMount ' + this.number) } catch (e) {}
-    },
-    mounted () {
-      try { __lifecycles.push('mounted ' + this.number) } catch (e) {}
-      this.number++
-    },
-    beforeUpdate () {
-      try { __lifecycles.push('beforeUpdate ' + this.number) } catch (e) {}
-    },
-    updated () {
-      try { __lifecycles.push('updated ' + this.number) } catch (e) {}
-    },
-    beforeDestroy () {
-      try { __lifecycles.push('beforeDestroy ' + this.number) } catch (e) {}
-    },
-    destroyed () {
-      try { __lifecycles.push('destroyed ' + this.number) } catch (e) {}
-    }
-  }
-</script>
diff --git a/1.Vue/test/weex/cases/recycle-list/components/poster.vue b/1.Vue/test/weex/cases/recycle-list/components/poster.vue
deleted file mode 100644
index 6157185..0000000
--- a/1.Vue/test/weex/cases/recycle-list/components/poster.vue
+++ /dev/null
@@ -1,33 +0,0 @@
-<template recyclable="true">
-  <div>
-    <image class="image" :src="imageUrl"></image>
-    <text class="title">{{title}}</text>
-  </div>
-</template>
-
-<script>
-  module.exports = {
-    props: {
-      imageUrl: {
-        type: String,
-        default: 'https://gw.alicdn.com/tfs/TB1KF_ybRTH8KJjy0FiXXcRsXXa-890-1186.png'
-      },
-      title: {
-        type: String,
-        default: 'I WANT YOU!'
-      }
-    }
-  }
-</script>
-
-<style scoped>
-  .image {
-    width: 750px;
-    height: 1000px;
-  }
-  .title {
-    font-size: 80px;
-    text-align: center;
-    color: #E95659;
-  }
-</style>
diff --git a/1.Vue/test/weex/cases/recycle-list/components/stateful-lifecycle.vdom.js b/1.Vue/test/weex/cases/recycle-list/components/stateful-lifecycle.vdom.js
deleted file mode 100644
index 45268ff..0000000
--- a/1.Vue/test/weex/cases/recycle-list/components/stateful-lifecycle.vdom.js
+++ /dev/null
@@ -1,29 +0,0 @@
-({
-  type: 'recycle-list',
-  attr: {
-    append: 'tree',
-    listData: [
-      { type: 'X' },
-      { type: 'X' }
-    ],
-    switch: 'type',
-    alias: 'item'
-  },
-  children: [{
-    type: 'cell-slot',
-    attr: { append: 'tree', case: 'X' },
-    children: [{
-      type: 'div',
-      attr: {
-        '@isComponentRoot': true,
-        '@componentProps': {}
-      },
-      children: [{
-        type: 'text',
-        attr: {
-          value: { '@binding': 'number' }
-        }
-      }]
-    }]
-  }]
-})
diff --git a/1.Vue/test/weex/cases/recycle-list/components/stateful-lifecycle.vue b/1.Vue/test/weex/cases/recycle-list/components/stateful-lifecycle.vue
deleted file mode 100644
index 97673b7..0000000
--- a/1.Vue/test/weex/cases/recycle-list/components/stateful-lifecycle.vue
+++ /dev/null
@@ -1,21 +0,0 @@
-<template>
-  <recycle-list for="item in longList" switch="type">
-    <cell-slot case="X">
-      <lifecycle></lifecycle>
-    </cell-slot>
-  </recycle-list>
-</template>
-
-<script>
-  // require('./lifecycle.vue')
-  module.exports = {
-    data () {
-      return {
-        longList: [
-          { type: 'X' },
-          { type: 'X' }
-        ]
-      }
-    }
-  }
-</script>
diff --git a/1.Vue/test/weex/cases/recycle-list/components/stateful-v-model.vdom.js b/1.Vue/test/weex/cases/recycle-list/components/stateful-v-model.vdom.js
deleted file mode 100644
index f2d0d96..0000000
--- a/1.Vue/test/weex/cases/recycle-list/components/stateful-v-model.vdom.js
+++ /dev/null
@@ -1,40 +0,0 @@
-({
-  type: 'recycle-list',
-  attr: {
-    append: 'tree',
-    listData: [
-      { type: 'A' },
-      { type: 'A' }
-    ],
-    switch: 'type',
-    alias: 'item'
-  },
-  children: [{
-    type: 'cell-slot',
-    attr: { append: 'tree', case: 'A' },
-    children: [{
-      type: 'div',
-      attr: {
-        '@isComponentRoot': true,
-        '@componentProps': {
-          message: 'No binding'
-        }
-      },
-      children: [{
-        type: 'text',
-        classList: ['output'],
-        attr: {
-          value: { '@binding': 'output' }
-        }
-      }, {
-        type: 'input',
-        event: ['input'],
-        classList: ['input'],
-        attr: {
-          type: 'text',
-          value: 'No binding'
-        }
-      }]
-    }]
-  }]
-})
diff --git a/1.Vue/test/weex/cases/recycle-list/components/stateful-v-model.vue b/1.Vue/test/weex/cases/recycle-list/components/stateful-v-model.vue
deleted file mode 100644
index 3b7cc61..0000000
--- a/1.Vue/test/weex/cases/recycle-list/components/stateful-v-model.vue
+++ /dev/null
@@ -1,21 +0,0 @@
-<template>
-  <recycle-list for="item in longList" switch="type">
-    <cell-slot case="A">
-      <editor message="No binding"></editor>
-    </cell-slot>
-  </recycle-list>
-</template>
-
-<script>
-  // require('./editor.vue')
-  module.exports = {
-    data () {
-      return {
-        longList: [
-          { type: 'A' },
-          { type: 'A' }
-        ]
-      }
-    }
-  }
-</script>
diff --git a/1.Vue/test/weex/cases/recycle-list/components/stateful.vdom.js b/1.Vue/test/weex/cases/recycle-list/components/stateful.vdom.js
deleted file mode 100644
index 6a2bddc..0000000
--- a/1.Vue/test/weex/cases/recycle-list/components/stateful.vdom.js
+++ /dev/null
@@ -1,40 +0,0 @@
-({
-  type: 'recycle-list',
-  attr: {
-    append: 'tree',
-    listData: [
-      { type: 'A', number: 24 },
-      { type: 'A', number: 42 }
-    ],
-    switch: 'type',
-    alias: 'item'
-  },
-  children: [{
-    type: 'cell-slot',
-    attr: { append: 'tree', case: 'A' },
-    children: [{
-      type: 'div',
-      attr: {
-        '@isComponentRoot': true,
-        '@componentProps': {
-          start: { '@binding': 'item.number' }
-        }
-      },
-      children: [{
-        type: 'text',
-        classList: ['output'],
-        attr: {
-          value: { '@binding': 'count' } // need confirm
-        }
-      }, {
-        type: 'text',
-        event: ['click'],
-        classList: ['button'],
-        attr: { value: '+' }
-      }]
-    }, {
-      type: 'text',
-      attr: { value: 'other' }
-    }]
-  }]
-})
diff --git a/1.Vue/test/weex/cases/recycle-list/components/stateful.vue b/1.Vue/test/weex/cases/recycle-list/components/stateful.vue
deleted file mode 100644
index 797f3f5..0000000
--- a/1.Vue/test/weex/cases/recycle-list/components/stateful.vue
+++ /dev/null
@@ -1,22 +0,0 @@
-<template>
-  <recycle-list for="item in longList" switch="type">
-    <cell-slot case="A">
-      <counter :start="item.number"></counter>
-      <text>other</text>
-    </cell-slot>
-  </recycle-list>
-</template>
-
-<script>
-  // require('./counter.vue')
-  module.exports = {
-    data () {
-      return {
-        longList: [
-          { type: 'A', number: 24 },
-          { type: 'A', number: 42 }
-        ]
-      }
-    }
-  }
-</script>
diff --git a/1.Vue/test/weex/cases/recycle-list/components/stateless-multi-components.vdom.js b/1.Vue/test/weex/cases/recycle-list/components/stateless-multi-components.vdom.js
deleted file mode 100644
index 2e4b4d9..0000000
--- a/1.Vue/test/weex/cases/recycle-list/components/stateless-multi-components.vdom.js
+++ /dev/null
@@ -1,83 +0,0 @@
-({
-  type: 'recycle-list',
-  attr: {
-    append: 'tree',
-    listData: [
-      { type: 'A' },
-      { type: 'B', poster: 'yy', title: 'y' },
-      { type: 'A' }
-    ],
-    switch: 'type',
-    alias: 'item'
-  },
-  children: [{
-    type: 'cell-slot',
-    attr: { append: 'tree', case: 'A' },
-    children: [{
-      type: 'div',
-      attr: {
-        '@isComponentRoot': true,
-        '@componentProps': {}
-      },
-      classList: ['banner'],
-      children: [{
-        type: 'text',
-        classList: ['title'],
-        attr: { value: 'BANNER' }
-      }]
-    }, {
-      type: 'text',
-      attr: { value: '----' }
-    }, {
-      type: 'div',
-      attr: {
-        '@isComponentRoot': true,
-        '@componentProps': {}
-      },
-      classList: ['footer'],
-      children: [{
-        type: 'text',
-        classList: ['copyright'],
-        attr: { value: 'All rights reserved.' }
-      }]
-    }]
-  }, {
-    type: 'cell-slot',
-    attr: { append: 'tree', case: 'B' },
-    children: [{
-      type: 'div',
-      attr: {
-        '@isComponentRoot': true,
-        '@componentProps': {}
-      },
-      classList: ['banner'],
-      children: [{
-        type: 'text',
-        classList: ['title'],
-        attr: { value: 'BANNER' }
-      }]
-    }, {
-      type: 'div',
-      attr: {
-        '@isComponentRoot': true,
-        '@componentProps': {
-          imageUrl: { '@binding': 'item.poster' },
-          title: { '@binding': 'item.title' }
-        }
-      },
-      children: [{
-        type: 'image',
-        classList: ['image'],
-        attr: {
-          src: { '@binding': 'imageUrl' }
-        }
-      }, {
-        type: 'text',
-        classList: ['title'],
-        attr: {
-          value: { '@binding': 'title' }
-        }
-      }]
-    }]
-  }]
-})
diff --git a/1.Vue/test/weex/cases/recycle-list/components/stateless-multi-components.vue b/1.Vue/test/weex/cases/recycle-list/components/stateless-multi-components.vue
deleted file mode 100644
index 9a6d6bf..0000000
--- a/1.Vue/test/weex/cases/recycle-list/components/stateless-multi-components.vue
+++ /dev/null
@@ -1,30 +0,0 @@
-<template>
-  <recycle-list for="item in longList" switch="type">
-    <cell-slot case="A">
-      <banner></banner>
-      <text>----</text>
-      <footer></footer>
-    </cell-slot>
-    <cell-slot case="B">
-      <banner></banner>
-      <poster :image-url="item.poster" :title="item.title"></poster>
-    </cell-slot>
-  </recycle-list>
-</template>
-
-<script>
-  // require('./banner.vue')
-  // require('./footer.vue')
-  // require('./poster.vue')
-  module.exports = {
-    data () {
-      return {
-        longList: [
-          { type: 'A' },
-          { type: 'B', poster: 'yy', title: 'y' },
-          { type: 'A' }
-        ]
-      }
-    }
-  }
-</script>
diff --git a/1.Vue/test/weex/cases/recycle-list/components/stateless-with-props.vdom.js b/1.Vue/test/weex/cases/recycle-list/components/stateless-with-props.vdom.js
deleted file mode 100644
index 3fc18dc..0000000
--- a/1.Vue/test/weex/cases/recycle-list/components/stateless-with-props.vdom.js
+++ /dev/null
@@ -1,44 +0,0 @@
-({
-  type: 'recycle-list',
-  attr: {
-    append: 'tree',
-    listData: [
-      { type: 'A', poster: 'xx', title: 'x' },
-      { type: 'A', poster: 'yy', title: 'y' }
-    ],
-    switch: 'type',
-    alias: 'item'
-  },
-  children: [{
-    type: 'cell-slot',
-    attr: { append: 'tree', case: 'A' },
-    children: [{
-      type: 'div',
-      attr: {
-        '@isComponentRoot': true,
-        '@componentProps': {
-          imageUrl: { '@binding': 'item.poster' },
-          title: { '@binding': 'item.title' }
-        }
-      },
-      children: [{
-        type: 'image',
-        classList: ['image'],
-        attr: {
-          src: { '@binding': 'imageUrl' }
-        }
-      }, {
-        type: 'text',
-        classList: ['title'],
-        attr: {
-          value: { '@binding': 'title' }
-        }
-      }]
-    }, {
-      type: 'text',
-      attr: {
-        value: 'content'
-      }
-    }]
-  }]
-})
diff --git a/1.Vue/test/weex/cases/recycle-list/components/stateless-with-props.vue b/1.Vue/test/weex/cases/recycle-list/components/stateless-with-props.vue
deleted file mode 100644
index e1d3d8c..0000000
--- a/1.Vue/test/weex/cases/recycle-list/components/stateless-with-props.vue
+++ /dev/null
@@ -1,22 +0,0 @@
-<template>
-  <recycle-list for="item in longList" switch="type">
-    <cell-slot case="A">
-      <poster :image-url="item.poster" :title="item.title"></poster>
-      <text>content</text>
-    </cell-slot>
-  </recycle-list>
-</template>
-
-<script>
-  // require('./poster.vue')
-  module.exports = {
-    data () {
-      return {
-        longList: [
-          { type: 'A', poster: 'xx', title: 'x' },
-          { type: 'A', poster: 'yy', title: 'y' }
-        ]
-      }
-    }
-  }
-</script>
diff --git a/1.Vue/test/weex/cases/recycle-list/components/stateless.vdom.js b/1.Vue/test/weex/cases/recycle-list/components/stateless.vdom.js
deleted file mode 100644
index 3ae12d0..0000000
--- a/1.Vue/test/weex/cases/recycle-list/components/stateless.vdom.js
+++ /dev/null
@@ -1,36 +0,0 @@
-({
-  type: 'recycle-list',
-  attr: {
-    append: 'tree',
-    listData: [
-      { type: 'A' },
-      { type: 'A' }
-    ],
-    switch: 'type',
-    alias: 'item'
-  },
-  children: [{
-    type: 'cell-slot',
-    attr: { append: 'tree', case: 'A' },
-    children: [{
-      type: 'div',
-      attr: {
-        '@isComponentRoot': true,
-        '@componentProps': {}
-      },
-      classList: ['banner'],
-      children: [{
-        type: 'text',
-        classList: ['title'],
-        attr: {
-          value: 'BANNER'
-        }
-      }]
-    }, {
-      type: 'text',
-      attr: {
-        value: 'content'
-      }
-    }]
-  }]
-})
diff --git a/1.Vue/test/weex/cases/recycle-list/components/stateless.vue b/1.Vue/test/weex/cases/recycle-list/components/stateless.vue
deleted file mode 100644
index 3ad942d..0000000
--- a/1.Vue/test/weex/cases/recycle-list/components/stateless.vue
+++ /dev/null
@@ -1,22 +0,0 @@
-<template>
-  <recycle-list for="item in longList" switch="type">
-    <cell-slot case="A">
-      <banner></banner>
-      <text>content</text>
-    </cell-slot>
-  </recycle-list>
-</template>
-
-<script>
-  // require('./banner.vue')
-  module.exports = {
-    data () {
-      return {
-        longList: [
-          { type: 'A' },
-          { type: 'A' }
-        ]
-      }
-    }
-  }
-</script>
diff --git a/1.Vue/test/weex/cases/recycle-list/inline-style.vdom.js b/1.Vue/test/weex/cases/recycle-list/inline-style.vdom.js
deleted file mode 100644
index c29bcf9..0000000
--- a/1.Vue/test/weex/cases/recycle-list/inline-style.vdom.js
+++ /dev/null
@@ -1,29 +0,0 @@
-({
-  type: 'recycle-list',
-  attr: {
-    append: 'tree',
-    listData: [
-      { type: 'A', color: '#606060' },
-      { type: 'A', color: '#E5E5E5' }
-    ],
-    switch: 'type',
-    alias: 'item'
-  },
-  children: [{
-    type: 'cell-slot',
-    attr: { append: 'tree', case: 'A' },
-    style: {
-      backgroundColor: '#FF6600'
-    },
-    children: [{
-      type: 'text',
-      style: {
-        fontSize: '100px',
-        color: { '@binding': 'item.color' }
-      },
-      attr: {
-        value: 'content'
-      }
-    }]
-  }]
-})
diff --git a/1.Vue/test/weex/cases/recycle-list/inline-style.vue b/1.Vue/test/weex/cases/recycle-list/inline-style.vue
deleted file mode 100644
index af9da5b..0000000
--- a/1.Vue/test/weex/cases/recycle-list/inline-style.vue
+++ /dev/null
@@ -1,21 +0,0 @@
-<template>
-  <recycle-list for="item in longList" switch="type">
-    <cell-slot case="A" style="background-color:#FF6600">
-      <text :style="{ fontSize: '100px', color: item.color }">content</text>
-    </cell-slot>
-  </recycle-list>
-</template>
-
-<script>
-  module.exports = {
-    data () {
-      return {
-        longList: [
-          { type: 'A', color: '#606060' },
-          { type: 'A', color: '#E5E5E5' }
-        ]
-      }
-    }
-  }
-</script>
-
diff --git a/1.Vue/test/weex/cases/recycle-list/text-node.vdom.js b/1.Vue/test/weex/cases/recycle-list/text-node.vdom.js
deleted file mode 100644
index 6ab5d1e..0000000
--- a/1.Vue/test/weex/cases/recycle-list/text-node.vdom.js
+++ /dev/null
@@ -1,38 +0,0 @@
-({
-  type: 'recycle-list',
-  attr: {
-    append: 'tree',
-    listData: [
-      { type: 'A', dynamic: 'decimal', two: '2', four: '4' },
-      { type: 'A', dynamic: 'binary', two: '10', four: '100' }
-    ],
-    switch: 'type',
-    alias: 'item'
-  },
-  children: [{
-    type: 'cell-slot',
-    attr: { append: 'tree', case: 'A' },
-    children: [{
-      type: 'text',
-      attr: {
-        value: 'static'
-      }
-    }, {
-      type: 'text',
-      attr: {
-        value: { '@binding': 'item.dynamic' }
-      }
-    }, {
-      type: 'text',
-      attr: {
-        value: [
-          'one ',
-          { '@binding': 'item.two' },
-          ' three ',
-          { '@binding': 'item.four' },
-          ' five'
-        ]
-      }
-    }]
-  }]
-})
diff --git a/1.Vue/test/weex/cases/recycle-list/text-node.vue b/1.Vue/test/weex/cases/recycle-list/text-node.vue
deleted file mode 100644
index 56b21ca..0000000
--- a/1.Vue/test/weex/cases/recycle-list/text-node.vue
+++ /dev/null
@@ -1,23 +0,0 @@
-<template>
-  <recycle-list for="item in longList" switch="type">
-    <cell-slot case="A">
-      <text>static</text>
-      <text>{{item.dynamic}}</text>
-      <text>one {{item.two}} three {{ item.four }} five</text>
-    </cell-slot>
-  </recycle-list>
-</template>
-
-<script>
-  module.exports = {
-    data () {
-      return {
-        longList: [
-          { type: 'A', dynamic: 'decimal', two: '2', four: '4' },
-          { type: 'A', dynamic: 'binary', two: '10', four: '100' }
-        ]
-      }
-    }
-  }
-</script>
-
diff --git a/1.Vue/test/weex/cases/recycle-list/v-else-if.vdom.js b/1.Vue/test/weex/cases/recycle-list/v-else-if.vdom.js
deleted file mode 100644
index 1181e26..0000000
--- a/1.Vue/test/weex/cases/recycle-list/v-else-if.vdom.js
+++ /dev/null
@@ -1,35 +0,0 @@
-({
-  type: 'recycle-list',
-  attr: {
-    append: 'tree',
-    listData: [
-      { type: 'A' },
-      { type: 'A' }
-    ],
-    switch: 'type',
-    alias: 'item'
-  },
-  children: [{
-    type: 'cell-slot',
-    attr: { append: 'tree', case: 'A' },
-    children: [{
-      type: 'image',
-      attr: {
-        '[[match]]': 'item.sourceA',
-        src: { '@binding': 'item.sourceA' }
-      }
-    }, {
-      type: 'image',
-      attr: {
-        '[[match]]': '!(item.sourceA) && (item.sourceB)',
-        src: { '@binding': 'item.sourceB' }
-      }
-    }, {
-      type: 'image',
-      attr: {
-        '[[match]]': '!(item.sourceA || item.sourceB)',
-        src: { '@binding': 'item.placeholder' }
-      }
-    }]
-  }]
-})
diff --git a/1.Vue/test/weex/cases/recycle-list/v-else-if.vue b/1.Vue/test/weex/cases/recycle-list/v-else-if.vue
deleted file mode 100644
index 6078450..0000000
--- a/1.Vue/test/weex/cases/recycle-list/v-else-if.vue
+++ /dev/null
@@ -1,23 +0,0 @@
-<template>
-  <recycle-list for="item in longList" switch="type">
-    <cell-slot case="A">
-      <image v-if="item.sourceA" :src="item.sourceA"></image>
-      <image v-else-if="item.sourceB" :src="item.sourceB"></image>
-      <image v-else :src="item.placeholder"></image>
-    </cell-slot>
-  </recycle-list>
-</template>
-
-<script>
-  module.exports = {
-    data () {
-      return {
-        longList: [
-          { type: 'A' },
-          { type: 'A' }
-        ]
-      }
-    }
-  }
-</script>
-
diff --git a/1.Vue/test/weex/cases/recycle-list/v-else.vdom.js b/1.Vue/test/weex/cases/recycle-list/v-else.vdom.js
deleted file mode 100644
index dc37e1d..0000000
--- a/1.Vue/test/weex/cases/recycle-list/v-else.vdom.js
+++ /dev/null
@@ -1,29 +0,0 @@
-({
-  type: 'recycle-list',
-  attr: {
-    append: 'tree',
-    listData: [
-      { type: 'A' },
-      { type: 'A' }
-    ],
-    switch: 'type',
-    alias: 'item'
-  },
-  children: [{
-    type: 'cell-slot',
-    attr: { append: 'tree', case: 'A' },
-    children: [{
-      type: 'image',
-      attr: {
-        '[[match]]': 'item.source',
-        src: { '@binding': 'item.source' }
-      }
-    }, {
-      type: 'image',
-      attr: {
-        '[[match]]': '!(item.source)',
-        src: { '@binding': 'item.placeholder' }
-      }
-    }]
-  }]
-})
diff --git a/1.Vue/test/weex/cases/recycle-list/v-else.vue b/1.Vue/test/weex/cases/recycle-list/v-else.vue
deleted file mode 100644
index 48e85fd..0000000
--- a/1.Vue/test/weex/cases/recycle-list/v-else.vue
+++ /dev/null
@@ -1,22 +0,0 @@
-<template>
-  <recycle-list for="item in longList" switch="type">
-    <cell-slot case="A">
-      <image v-if="item.source" :src="item.source"></image>
-      <image v-else v-bind:src="item.placeholder"></image>
-    </cell-slot>
-  </recycle-list>
-</template>
-
-<script>
-  module.exports = {
-    data () {
-      return {
-        longList: [
-          { type: 'A' },
-          { type: 'A' }
-        ]
-      }
-    }
-  }
-</script>
-
diff --git a/1.Vue/test/weex/cases/recycle-list/v-for-iterator.vdom.js b/1.Vue/test/weex/cases/recycle-list/v-for-iterator.vdom.js
deleted file mode 100644
index 5507403..0000000
--- a/1.Vue/test/weex/cases/recycle-list/v-for-iterator.vdom.js
+++ /dev/null
@@ -1,47 +0,0 @@
-({
-  type: 'recycle-list',
-  attr: {
-    append: 'tree',
-    listData: [
-      { type: 'A' },
-      { type: 'A' }
-    ],
-    switch: 'type',
-    alias: 'item'
-  },
-  children: [{
-    type: 'cell-slot',
-    attr: { append: 'tree', case: 'A' },
-    children: [{
-      type: 'div',
-      attr: {
-        '[[repeat]]': {
-          '@expression': 'item.list',
-          '@index': 'index',
-          '@alias': 'object'
-        }
-      },
-      children: [{
-        type: 'text',
-        attr: {
-          value: {
-            '@binding': 'object.name'
-          }
-        }
-      }, {
-        type: 'text',
-        attr: {
-          '[[repeat]]': {
-            '@expression': 'object',
-            '@alias': 'v',
-            '@key': 'k',
-            '@index': 'i'
-          },
-          value: {
-            '@binding': 'v'
-          }
-        }
-      }]
-    }]
-  }]
-})
diff --git a/1.Vue/test/weex/cases/recycle-list/v-for-iterator.vue b/1.Vue/test/weex/cases/recycle-list/v-for-iterator.vue
deleted file mode 100644
index ed424a2..0000000
--- a/1.Vue/test/weex/cases/recycle-list/v-for-iterator.vue
+++ /dev/null
@@ -1,24 +0,0 @@
-<template>
-  <recycle-list for="item in longList" switch="type">
-    <cell-slot case="A">
-      <div v-for="(object, index) in item.list" :key="index">
-        <text>{{object.name}}</text>
-        <text v-for="(v, k, i) in object" :key="k">{{v}}</text>
-      </div>
-    </cell-slot>
-  </recycle-list>
-</template>
-
-<script>
-  module.exports = {
-    data () {
-      return {
-        longList: [
-          { type: 'A' },
-          { type: 'A' }
-        ]
-      }
-    }
-  }
-</script>
-
diff --git a/1.Vue/test/weex/cases/recycle-list/v-for.vdom.js b/1.Vue/test/weex/cases/recycle-list/v-for.vdom.js
deleted file mode 100644
index bbae2d5..0000000
--- a/1.Vue/test/weex/cases/recycle-list/v-for.vdom.js
+++ /dev/null
@@ -1,33 +0,0 @@
-({
-  type: 'recycle-list',
-  attr: {
-    append: 'tree',
-    listData: [
-      { type: 'A' },
-      { type: 'A' }
-    ],
-    switch: 'type',
-    alias: 'item'
-  },
-  children: [{
-    type: 'cell-slot',
-    attr: { append: 'tree', case: 'A' },
-    children: [{
-      type: 'div',
-      attr: {
-        '[[repeat]]': {
-          '@expression': 'item.list',
-          '@alias': 'panel'
-        }
-      },
-      children: [{
-        type: 'text',
-        attr: {
-          value: {
-            '@binding': 'panel.label'
-          }
-        }
-      }]
-    }]
-  }]
-})
diff --git a/1.Vue/test/weex/cases/recycle-list/v-for.vue b/1.Vue/test/weex/cases/recycle-list/v-for.vue
deleted file mode 100644
index 57a6890..0000000
--- a/1.Vue/test/weex/cases/recycle-list/v-for.vue
+++ /dev/null
@@ -1,23 +0,0 @@
-<template>
-  <recycle-list for="item in longList" switch="type">
-    <cell-slot case="A">
-      <div v-for="panel in item.list" :key="panel.id">
-        <text>{{panel.label}}</text>
-      </div>
-    </cell-slot>
-  </recycle-list>
-</template>
-
-<script>
-  module.exports = {
-    data () {
-      return {
-        longList: [
-          { type: 'A' },
-          { type: 'A' }
-        ]
-      }
-    }
-  }
-</script>
-
diff --git a/1.Vue/test/weex/cases/recycle-list/v-if.vdom.js b/1.Vue/test/weex/cases/recycle-list/v-if.vdom.js
deleted file mode 100644
index fe5339b..0000000
--- a/1.Vue/test/weex/cases/recycle-list/v-if.vdom.js
+++ /dev/null
@@ -1,29 +0,0 @@
-({
-  type: 'recycle-list',
-  attr: {
-    append: 'tree',
-    listData: [
-      { type: 'A' },
-      { type: 'A' }
-    ],
-    switch: 'type',
-    alias: 'item'
-  },
-  children: [{
-    type: 'cell-slot',
-    attr: { append: 'tree', case: 'A' },
-    children: [{
-      type: 'image',
-      attr: {
-        '[[match]]': 'item.source',
-        src: { '@binding': 'item.source' }
-      }
-    }, {
-      type: 'text',
-      attr: {
-        '[[match]]': '!item.source',
-        value: 'Title'
-      }
-    }]
-  }]
-})
diff --git a/1.Vue/test/weex/cases/recycle-list/v-if.vue b/1.Vue/test/weex/cases/recycle-list/v-if.vue
deleted file mode 100644
index ab2e047..0000000
--- a/1.Vue/test/weex/cases/recycle-list/v-if.vue
+++ /dev/null
@@ -1,22 +0,0 @@
-<template>
-  <recycle-list for="item in longList" switch="type">
-    <cell-slot case="A">
-      <image v-if="item.source" :src="item.source"></image>
-      <text v-if="!item.source">Title</text>
-    </cell-slot>
-  </recycle-list>
-</template>
-
-<script>
-  module.exports = {
-    data () {
-      return {
-        longList: [
-          { type: 'A' },
-          { type: 'A' }
-        ]
-      }
-    }
-  }
-</script>
-
diff --git a/1.Vue/test/weex/cases/recycle-list/v-on-inline.vdom.js b/1.Vue/test/weex/cases/recycle-list/v-on-inline.vdom.js
deleted file mode 100644
index 461fb99..0000000
--- a/1.Vue/test/weex/cases/recycle-list/v-on-inline.vdom.js
+++ /dev/null
@@ -1,37 +0,0 @@
-({
-  type: 'recycle-list',
-  attr: {
-    append: 'tree',
-    listData: [
-      { type: 'A' },
-      { type: 'A' }
-    ],
-    switch: 'type',
-    alias: 'item'
-  },
-  children: [{
-    type: 'cell-slot',
-    attr: { append: 'tree', case: 'A' },
-    children: [{
-      type: 'text',
-      event: ['click', {
-        type: 'longpress',
-        params: [{ '@binding': 'item.key' }]
-      }]
-    }, {
-      type: 'text',
-      event: [{
-        type: 'appear',
-        params: [
-          { '@binding': 'item.index' },
-          { '@binding': 'item.type' }
-        ]
-      }],
-      attr: { value: 'Button' }
-    }, {
-      type: 'text',
-      event: [{ type: 'disappear' }],
-      attr: { value: 'Tips' }
-    }]
-  }]
-})
diff --git a/1.Vue/test/weex/cases/recycle-list/v-on-inline.vue b/1.Vue/test/weex/cases/recycle-list/v-on-inline.vue
deleted file mode 100644
index ae909b2..0000000
--- a/1.Vue/test/weex/cases/recycle-list/v-on-inline.vue
+++ /dev/null
@@ -1,28 +0,0 @@
-<template>
-  <recycle-list for="item in longList" switch="type">
-    <cell-slot case="A">
-      <text v-on:click="toggle()" @longpress="toggle(item.key)"></text>
-      <text @appear="onappear(item.index, 'static', item.type, $event)">Button</text>
-      <text @disappear="onappear(25, 'static')">Tips</text>
-    </cell-slot>
-  </recycle-list>
-</template>
-
-<script>
-  module.exports = {
-    data () {
-      return {
-        longList: [
-          { type: 'A' },
-          { type: 'A' }
-        ]
-      }
-    },
-    methods: {
-      hide () {},
-      toggle () {},
-      onappear () {}
-    }
-  }
-</script>
-
diff --git a/1.Vue/test/weex/cases/recycle-list/v-on.vdom.js b/1.Vue/test/weex/cases/recycle-list/v-on.vdom.js
deleted file mode 100644
index 3da8209..0000000
--- a/1.Vue/test/weex/cases/recycle-list/v-on.vdom.js
+++ /dev/null
@@ -1,25 +0,0 @@
-({
-  type: 'recycle-list',
-  attr: {
-    append: 'tree',
-    listData: [
-      { type: 'A' },
-      { type: 'A' }
-    ],
-    switch: 'type',
-    alias: 'item'
-  },
-  children: [{
-    type: 'cell-slot',
-    attr: { append: 'tree', case: 'A' },
-    children: [{
-      type: 'text',
-      event: ['click', 'longpress'],
-      attr: { value: 'A' }
-    }, {
-      type: 'text',
-      event: ['touchend'],
-      attr: { value: 'B' }
-    }]
-  }]
-})
diff --git a/1.Vue/test/weex/cases/recycle-list/v-on.vue b/1.Vue/test/weex/cases/recycle-list/v-on.vue
deleted file mode 100644
index fb40f15..0000000
--- a/1.Vue/test/weex/cases/recycle-list/v-on.vue
+++ /dev/null
@@ -1,26 +0,0 @@
-<template>
-  <recycle-list for="item in longList" switch="type">
-    <cell-slot case="A">
-      <text v-on:click="handler" @longpress="move">A</text>
-      <text @touchend="move">B</text>
-    </cell-slot>
-  </recycle-list>
-</template>
-
-<script>
-  module.exports = {
-    data () {
-      return {
-        longList: [
-          { type: 'A' },
-          { type: 'A' }
-        ]
-      }
-    },
-    methods: {
-      handler () {},
-      move () {}
-    }
-  }
-</script>
-
diff --git a/1.Vue/test/weex/cases/recycle-list/v-once.vdom.js b/1.Vue/test/weex/cases/recycle-list/v-once.vdom.js
deleted file mode 100644
index 07e6419..0000000
--- a/1.Vue/test/weex/cases/recycle-list/v-once.vdom.js
+++ /dev/null
@@ -1,22 +0,0 @@
-({
-  type: 'recycle-list',
-  attr: {
-    append: 'tree',
-    listData: [
-      { type: 'A' },
-      { type: 'A' }
-    ],
-    alias: 'item'
-  },
-  children: [{
-    type: 'cell-slot',
-    attr: { append: 'tree' },
-    children: [{
-      type: 'text',
-      attr: {
-        '[[once]]': true,
-        value: { '@binding': 'item.type' }
-      }
-    }]
-  }]
-})
diff --git a/1.Vue/test/weex/cases/recycle-list/v-once.vue b/1.Vue/test/weex/cases/recycle-list/v-once.vue
deleted file mode 100644
index f1e3a36..0000000
--- a/1.Vue/test/weex/cases/recycle-list/v-once.vue
+++ /dev/null
@@ -1,21 +0,0 @@
-<template>
-  <recycle-list for="item in list">
-    <cell-slot>
-      <text v-once>{{item.type}}</text>
-    </cell-slot>
-  </recycle-list>
-</template>
-
-<script>
-  module.exports = {
-    data () {
-      return {
-        list: [
-          { type: 'A' },
-          { type: 'A' }
-        ]
-      }
-    }
-  }
-</script>
-
diff --git a/1.Vue/test/weex/cases/render/class.vdom.js b/1.Vue/test/weex/cases/render/class.vdom.js
deleted file mode 100644
index 7dec4ab..0000000
--- a/1.Vue/test/weex/cases/render/class.vdom.js
+++ /dev/null
@@ -1,19 +0,0 @@
-({
-  type: 'div',
-  children: [{
-    type: 'div',
-    classList: ['box', 'box1']
-  }, {
-    type: 'div',
-    classList: ['box', 'box2']
-  }, {
-    type: 'div',
-    classList: ['box', 'box3']
-  }, {
-    type: 'div',
-    classList: ['box', 'box4']
-  }, {
-    type: 'div',
-    classList: ['box', 'box5']
-  }]
-})
diff --git a/1.Vue/test/weex/cases/render/class.vue b/1.Vue/test/weex/cases/render/class.vue
deleted file mode 100644
index f4443c5..0000000
--- a/1.Vue/test/weex/cases/render/class.vue
+++ /dev/null
@@ -1,56 +0,0 @@
-<template>
-  <div>
-    <div :class="class1"></div>
-    <div :class="class2"></div>
-    <div class="box" :class="class3"></div>
-    <div class="box" :class="class4"></div>
-    <div class="box" :class="{ box5: class5 }"></div>
-  </div>
-</template>
-
-<style scoped>
-  .box {
-    width: 100px;
-    height: 100px;
-  }
-
-  .box1 {
-    background-color: #DDD;
-  }
-
-  .box2 {
-    background-color: #CCC;
-  }
-
-  .box3 {
-    background-color: #BBB;
-  }
-
-  .box4 {
-    background-color: #AAA;
-  }
-
-  .box5 {
-    background-color: #999;
-  }
-</style>
-
-<script>
-  module.exports = {
-    data () {
-      return {
-        class1: ['box', 'box1'],
-        class2: {
-          'box': true,
-          'box1': false,
-          'box2': true
-        },
-        class3: ['box3'],
-        class4: {
-          'box4': true
-        },
-        class5: true
-      }
-    }
-  }
-</script>
\ No newline at end of file
diff --git a/1.Vue/test/weex/cases/render/sample.vdom.js b/1.Vue/test/weex/cases/render/sample.vdom.js
deleted file mode 100644
index 1d9b198..0000000
--- a/1.Vue/test/weex/cases/render/sample.vdom.js
+++ /dev/null
@@ -1,13 +0,0 @@
-({
-  type: 'div',
-  style: {
-    justifyContent: 'center'
-  },
-  children: [{
-    type: 'text',
-    attr: {
-      value: 'Yo'
-    },
-    classList: ['freestyle']
-  }]
-})
diff --git a/1.Vue/test/weex/cases/render/sample.vue b/1.Vue/test/weex/cases/render/sample.vue
deleted file mode 100644
index 0251b3d..0000000
--- a/1.Vue/test/weex/cases/render/sample.vue
+++ /dev/null
@@ -1,23 +0,0 @@
-<template>
-  <div style="justify-content:center">
-    <text class="freestyle">{{string}}</text>
-  </div>
-</template>
-
-<style scoped>
-  .freestyle {
-    color: #41B883;
-    font-size: 233px;
-    text-align: center;
-  }
-</style>
-
-<script>
-  module.exports = {
-    data () {
-      return {
-        string: 'Yo'
-      }
-    }
-  }
-</script>
diff --git a/1.Vue/test/weex/compiler/append.spec.js b/1.Vue/test/weex/compiler/append.spec.js
deleted file mode 100644
index c75267c..0000000
--- a/1.Vue/test/weex/compiler/append.spec.js
+++ /dev/null
@@ -1,47 +0,0 @@
-import { compile } from '../../../packages/weex-template-compiler'
-import { strToRegExp } from '../helpers/index'
-
-describe('append props', () => {
-  it('add append="tree" on <cell>', () => {
-    const { render, staticRenderFns, errors } = compile(`<list><cell></cell></list>`)
-    expect(render).not.toBeUndefined()
-    expect(staticRenderFns).not.toBeUndefined()
-    expect(staticRenderFns.length).toEqual(1)
-    expect(staticRenderFns).toMatch(strToRegExp(`appendAsTree:true`))
-    expect(staticRenderFns).toMatch(strToRegExp(`attrs:{"append":"tree"}`))
-    expect(errors).toEqual([])
-  })
-
-  it('override append="node" on <cell>', () => {
-    const { render, staticRenderFns, errors } = compile(`<list><cell append="node"></cell></list>`)
-    expect(render + staticRenderFns).toMatch(strToRegExp(`attrs:{"append":"node"}`))
-    expect(errors).toEqual([])
-  })
-
-  it('add append="tree" on <header>', () => {
-    const { render, staticRenderFns, errors } = compile(`<list><header></header></list>`)
-    expect(render + staticRenderFns).toMatch(strToRegExp(`appendAsTree:true`))
-    expect(render + staticRenderFns).toMatch(strToRegExp(`attrs:{"append":"tree"}`))
-    expect(errors).toEqual([])
-  })
-
-  it('add append="tree" on <recycle-list>', () => {
-    const { render, staticRenderFns, errors } = compile(`<recycle-list for="item in list"><div></div></recycle-list>`)
-    expect(render + staticRenderFns).toMatch(strToRegExp(`appendAsTree:true`))
-    expect(render + staticRenderFns).toMatch(strToRegExp(`"append":"tree"`))
-    expect(errors).toEqual([])
-  })
-
-  it('add append="tree" on <cell-slot>', () => {
-    const { render, staticRenderFns, errors } = compile(`<list><cell-slot></cell-slot></list>`)
-    expect(render + staticRenderFns).toMatch(strToRegExp(`appendAsTree:true`))
-    expect(render + staticRenderFns).toMatch(strToRegExp(`attrs:{"append":"tree"}`))
-    expect(errors).toEqual([])
-  })
-
-  it('override append="node" on <cell-slot>', () => {
-    const { render, staticRenderFns, errors } = compile(`<list><cell-slot append="node"></cell-slot></list>`)
-    expect(render + staticRenderFns).toMatch(strToRegExp(`attrs:{"append":"node"}`))
-    expect(errors).toEqual([])
-  })
-})
diff --git a/1.Vue/test/weex/compiler/class.spec.js b/1.Vue/test/weex/compiler/class.spec.js
deleted file mode 100644
index a7e88ab..0000000
--- a/1.Vue/test/weex/compiler/class.spec.js
+++ /dev/null
@@ -1,56 +0,0 @@
-import { compile } from '../../../packages/weex-template-compiler'
-import { strToRegExp } from '../helpers/index'
-
-describe('compile class', () => {
-  it('should be compiled', () => {
-    const { render, staticRenderFns, errors } = compile(`<div class="a b c"></div>`)
-    expect(render).not.toBeUndefined()
-    expect(staticRenderFns).not.toBeUndefined()
-    expect(staticRenderFns.length).toEqual(0)
-    expect(render).toMatch(strToRegExp(`staticClass:["a","b","c"]`))
-    expect(errors).toEqual([])
-  })
-
-  it('should compile dynamic class', () => {
-    const { render, staticRenderFns, errors } = compile(`<div class="a {{b}} c"></div>`)
-    expect(render).not.toBeUndefined()
-    expect(staticRenderFns).toEqual([])
-    expect(render).toMatch(strToRegExp(`class:["a",_s(b),"c"]`))
-    expect(errors).not.toBeUndefined()
-    expect(errors.length).toEqual(1)
-    expect(errors[0]).toMatch(strToRegExp(`a {{b}} c`))
-    expect(errors[0]).toMatch(strToRegExp(`v-bind`))
-  })
-
-  it('should compile class binding of array', () => {
-    const { render, staticRenderFns, errors } = compile(`<div v-bind:class="['a', 'b', c]"></div>`)
-    expect(render).not.toBeUndefined()
-    expect(staticRenderFns).toEqual([])
-    expect(render).toMatch(strToRegExp(`class:['a', 'b', c]`))
-    expect(errors).toEqual([])
-  })
-
-  it('should compile class binding of map', () => {
-    const { render, staticRenderFns, errors } = compile(`<div v-bind:class="{ a: true, b: x }"></div>`)
-    expect(render).not.toBeUndefined()
-    expect(staticRenderFns).toEqual([])
-    expect(render).toMatch(strToRegExp(`class:{ a: true, b: x }`))
-    expect(errors).toEqual([])
-  })
-
-  it('should compile class binding of a variable', () => {
-    const { render, staticRenderFns, errors } = compile(`<div v-bind:class="x"></div>`)
-    expect(render).not.toBeUndefined()
-    expect(staticRenderFns).toEqual([])
-    expect(render).toMatch(strToRegExp(`class:x`))
-    expect(errors).toEqual([])
-  })
-
-  it('should compile class binding by shorthand', () => {
-    const { render, staticRenderFns, errors } = compile(`<div :class="['a', 'b', c]"></div>`)
-    expect(render).not.toBeUndefined()
-    expect(staticRenderFns).toEqual([])
-    expect(render).toMatch(strToRegExp(`class:['a', 'b', c]`))
-    expect(errors).toEqual([])
-  })
-})
diff --git a/1.Vue/test/weex/compiler/compile.spec.js b/1.Vue/test/weex/compiler/compile.spec.js
deleted file mode 100644
index 7a717f1..0000000
--- a/1.Vue/test/weex/compiler/compile.spec.js
+++ /dev/null
@@ -1,76 +0,0 @@
-import { compile } from '../../../packages/weex-template-compiler'
-import { strToRegExp } from '../helpers/index'
-
-describe('compile basic', () => {
-  it('should be compiled', () => {
-    const { render, staticRenderFns, errors } = compile(`<div>{{hi}}</div>`)
-    expect(render).toEqual(`with(this){return _c('div',[_v(_s(hi))])}`)
-    expect(staticRenderFns.length).toBe(0)
-    expect(errors).toEqual([])
-  })
-
-  it('should compile data bindings', () => {
-    const { render, staticRenderFns, errors } = compile(`<div :a="b"></div>`)
-    expect(render).toEqual(`with(this){return _c('div',{attrs:{"a":b}})}`)
-    expect(staticRenderFns).toEqual([])
-    expect(errors).toEqual([])
-  })
-
-  it('should compile event bindings', () => {
-    const { render, staticRenderFns, errors } = compile(`<div @click="x"></div>`)
-    expect(render).toEqual(`with(this){return _c('div',{on:{"click":x}})}`)
-    expect(staticRenderFns).toEqual([])
-    expect(errors).toEqual([])
-  })
-
-  it('should compile data bindings with children', () => {
-    const { render, staticRenderFns, errors } = compile(`<foo :a="b"><text>Hello</text></foo>`)
-    expect(render).toEqual(`with(this){return _c('foo',{attrs:{"a":b}},[_c('text',[_v("Hello")])])}`)
-    expect(staticRenderFns).toEqual([])
-    expect(errors).toEqual([])
-  })
-
-  it('should compile unary tag', () => {
-    const inputCase = compile(`<div><input><text>abc</text></div>`)
-    expect(inputCase.render).toMatch(strToRegExp(`return _m(0)`))
-    expect(inputCase.staticRenderFns).toMatch(strToRegExp(`_c('div',[_c('input'),_c('text',[_v("abc")])])`))
-    expect(inputCase.errors).toEqual([])
-
-    const imageCase = compile(`<div><image src="path"><text>abc</text></div>`)
-    expect(imageCase.render).toMatch(strToRegExp(`return _m(0)`))
-    expect(imageCase.staticRenderFns).toMatch(strToRegExp(`_c('div',[_c('image',{attrs:{"src":"path"}}),_c('text',[_v("abc")])])`))
-    expect(imageCase.errors).toEqual([])
-
-    const complexCase = compile(`
-      <div>
-        <image src="path">
-        <image></image>
-        <div>
-          <embed>
-          <text>start</text>
-          <input type="text">
-          <input type="url" />
-          <text>end</text>
-        </div>
-      </div>
-    `)
-    expect(complexCase.render).toMatch(strToRegExp(`return _m(0)`))
-    expect(complexCase.staticRenderFns).toMatch(strToRegExp(`_c('image',{attrs:{"src":"path"}}),_c('image'),_c('div'`))
-    expect(complexCase.staticRenderFns).toMatch(strToRegExp(`_c('div',[_c('embed'),_c('text',[_v("start")]),_c('input',{attrs:{"type":"text"}}),_c('input',{attrs:{"type":"url"}}),_c('text',[_v("end")])]`))
-    expect(complexCase.errors).toEqual([])
-  })
-
-  it('should compile more complex situation', () => {
-    // from examples of https://github.com/alibaba/weex
-    const { render, staticRenderFns, errors } = compile(`
-      <refresh class="refresh" @refresh="handleRefresh" :display="displayRefresh"
-        style="flex-direction:row;">
-        <loading-indicator></loading-indicator>
-        <text style="margin-left:36px;color:#eee;">Load more...</text>
-      </refresh>
-    `)
-    expect(render).toEqual(`with(this){return _c('refresh',{staticClass:["refresh"],staticStyle:{flexDirection:"row"},attrs:{"display":displayRefresh},on:{"refresh":handleRefresh}},[_c('loading-indicator'),_c('text',{staticStyle:{marginLeft:"36px",color:"#eee"}},[_v("Load more...")])])}`)
-    expect(staticRenderFns).toEqual([])
-    expect(errors).toEqual([])
-  })
-})
diff --git a/1.Vue/test/weex/compiler/parser.spec.js b/1.Vue/test/weex/compiler/parser.spec.js
deleted file mode 100644
index 1d560b5..0000000
--- a/1.Vue/test/weex/compiler/parser.spec.js
+++ /dev/null
@@ -1,105 +0,0 @@
-import { generateBinding } from '../../../src/platforms/weex/util/parser'
-
-describe('expression parser', () => {
-  describe('generateBinding', () => {
-    it('primitive literal', () => {
-      expect(generateBinding('15')).toEqual(15)
-      expect(generateBinding('"xxx"')).toEqual('xxx')
-    })
-
-    it('identifiers', () => {
-      expect(generateBinding('x')).toEqual({ '@binding': 'x' })
-      expect(generateBinding('x.y')).toEqual({ '@binding': 'x.y' })
-      expect(generateBinding(`x.y['z']`)).toEqual({ '@binding': `x.y['z']` })
-    })
-
-    it('object literal', () => {
-      expect(generateBinding('{}')).toEqual({})
-      expect(generateBinding('{ abc: 25 }')).toEqual({ abc: 25 })
-      expect(generateBinding('{ abc: 25, def: "xxx" }')).toEqual({ abc: 25, def: 'xxx' })
-      expect(generateBinding('{ a: 3, b: { bb: "bb", bbb: { bbc: "BBC" } } }'))
-        .toEqual({ a: 3, b: { bb: 'bb', bbb: { bbc: 'BBC' }}})
-    })
-
-    it('array literal', () => {
-      expect(generateBinding('[]')).toEqual([])
-      expect(generateBinding('[{ abc: 25 }]')).toEqual([{ abc: 25 }])
-      expect(generateBinding('[{ abc: 25, def: ["xxx"] }]')).toEqual([{ abc: 25, def: ['xxx'] }])
-      expect(generateBinding('{ a: [3,16], b: [{ bb: ["aa","bb"], bbb: [{bbc:"BBC"}] }] }'))
-        .toEqual({ a: [3, 16], b: [{ bb: ['aa', 'bb'], bbb: [{ bbc: 'BBC' }] }] })
-    })
-
-    it('expressions', () => {
-      expect(generateBinding(`3 + 5`)).toEqual({ '@binding': `3 + 5` })
-      expect(generateBinding(`'x' + 2`)).toEqual({ '@binding': `'x' + 2` })
-      expect(generateBinding(`\`xx\` + 2`)).toEqual({ '@binding': `\`xx\` + 2` })
-      expect(generateBinding(`item.size * 23 + 'px'`)).toEqual({ '@binding': `item.size * 23 + 'px'` })
-    })
-
-    it('object bindings', () => {
-      expect(generateBinding(`{ color: textColor }`)).toEqual({
-        color: { '@binding': 'textColor' }
-      })
-      expect(generateBinding(`{ color: '#FF' + 66 * 100, fontSize: item.size }`)).toEqual({
-        color: { '@binding': `'#FF' + 66 * 100` },
-        fontSize: { '@binding': 'item.size' }
-      })
-      expect(generateBinding(`{
-        x: { xx: obj, xy: -2 + 5 },
-        y: {
-          yy: { yyy: obj.y || yy },
-          yz: typeof object.yz === 'string' ? object.yz : ''
-        }
-      }`)).toEqual({
-        x: { xx: { '@binding': 'obj' }, xy: { '@binding': '-2 + 5' }},
-        y: {
-          yy: { yyy: { '@binding': 'obj.y || yy' }},
-          yz: { '@binding': `typeof object.yz === 'string' ? object.yz : ''` }
-        }
-      })
-    })
-
-    it('array bindings', () => {
-      expect(generateBinding(`[textColor, 3 + 5, 'string']`)).toEqual([
-        { '@binding': 'textColor' },
-        { '@binding': '3 + 5' },
-        'string'
-      ])
-      expect(generateBinding(`[
-        { color: '#FF' + 66 * -100 },
-        item && item.style,
-        { fontSize: item.size | 0 }
-      ]`)).toEqual([
-        { color: { '@binding': `'#FF' + 66 * -100` }},
-        { '@binding': 'item && item.style' },
-        { fontSize: { '@binding': 'item.size | 0' }}
-      ])
-      expect(generateBinding(`[{
-        x: [{ xx: [fn instanceof Function ? 'function' : '' , 25] }],
-        y: {
-          yy: [{ yyy: [obj.yy.y, obj.y.yy] }],
-          yz: [object.yz, void 0]
-        }
-      }]`)).toEqual([{
-        x: [{ xx: [{ '@binding': `fn instanceof Function ? 'function' : ''` }, 25] }],
-        y: {
-          yy: [{ yyy: [{ '@binding': 'obj.yy.y' }, { '@binding': 'obj.y.yy' }] }],
-          yz: [{ '@binding': 'object.yz' }, { '@binding': 'void 0' }]
-        }
-      }])
-    })
-
-    it('unsupported bindings', () => {
-      expect(generateBinding('() => {}')).toEqual('')
-      expect(generateBinding('function(){}')).toEqual('')
-      expect(generateBinding('(function(){})()')).toEqual('')
-      expect(generateBinding('var abc = 35')).toEqual('')
-      expect(generateBinding('abc++')).toEqual('')
-      expect(generateBinding('x.y(0)')).toEqual('')
-      expect(generateBinding('class X {}')).toEqual('')
-      expect(generateBinding('if (typeof x == null) { 35 }')).toEqual('')
-      expect(generateBinding('while (x == null)')).toEqual('')
-      expect(generateBinding('new Function()')).toEqual('')
-    })
-  })
-})
diff --git a/1.Vue/test/weex/compiler/props.spec.js b/1.Vue/test/weex/compiler/props.spec.js
deleted file mode 100644
index 85f4e10..0000000
--- a/1.Vue/test/weex/compiler/props.spec.js
+++ /dev/null
@@ -1,22 +0,0 @@
-import { compile } from '../../../packages/weex-template-compiler'
-import { strToRegExp } from '../helpers/index'
-
-describe('compile props', () => {
-  it('custom props', () => {
-    const { render, staticRenderFns, errors } = compile(`<div custom="whatever"></div>`)
-    expect(render).not.toBeUndefined()
-    expect(staticRenderFns).not.toBeUndefined()
-    expect(staticRenderFns.length).toEqual(0)
-    expect(render).toMatch(strToRegExp(`attrs:{"custom":"whatever"}`))
-    expect(errors).toEqual([])
-  })
-
-  it('camelize props', () => {
-    const { render, staticRenderFns, errors } = compile(`<div kebab-case="whatever"></div>`)
-    expect(render).not.toBeUndefined()
-    expect(staticRenderFns).not.toBeUndefined()
-    expect(staticRenderFns.length).toEqual(0)
-    expect(render).toMatch(strToRegExp(`attrs:{"kebabCase":"whatever"}`))
-    expect(errors).toEqual([])
-  })
-})
diff --git a/1.Vue/test/weex/compiler/style.spec.js b/1.Vue/test/weex/compiler/style.spec.js
deleted file mode 100644
index efde3c3..0000000
--- a/1.Vue/test/weex/compiler/style.spec.js
+++ /dev/null
@@ -1,83 +0,0 @@
-import { compile } from '../../../packages/weex-template-compiler'
-import { strToRegExp } from '../helpers/index'
-
-describe('compile style', () => {
-  it('should be compiled', () => {
-    const { render, staticRenderFns, errors } = compile(`<div style="a: x; b: y"></div>`)
-    expect(render).not.toBeUndefined()
-    expect(staticRenderFns).not.toBeUndefined()
-    expect(staticRenderFns.length).toEqual(0)
-    expect(render).toMatch(strToRegExp(`staticStyle:{a:"x",b:"y"}`))
-    expect(errors).toEqual([])
-  })
-
-  it('should compile empty style value', () => {
-    const { render, staticRenderFns, errors } = compile(`<div style=""></div>`)
-    expect(render).not.toBeUndefined()
-    expect(staticRenderFns).not.toBeUndefined()
-    expect(staticRenderFns.length).toEqual(0)
-    expect(render).toMatch(/[(^style|^staticStyle)]/)
-    expect(errors).toEqual([])
-  })
-
-  it('should compile style value with trailing semicolon', () => {
-    const { render, staticRenderFns, errors } = compile(`<div style="a: x; b: y;"></div>`)
-    expect(render).not.toBeUndefined()
-    expect(staticRenderFns).not.toBeUndefined()
-    expect(staticRenderFns.length).toEqual(0)
-    expect(render).toMatch(strToRegExp(`staticStyle:{a:"x",b:"y"}`))
-    expect(errors).toEqual([])
-  })
-
-  it('should compile hyphenated style name & value', () => {
-    const { render, staticRenderFns, errors } = compile(`<div style="-abc-def: x-y; abc-def: x-y"></div>`)
-    expect(render).not.toBeUndefined()
-    expect(staticRenderFns).not.toBeUndefined()
-    expect(staticRenderFns.length).toEqual(0)
-    expect(render).toMatch(strToRegExp(`staticStyle:{AbcDef:"x-y",abcDef:"x-y"}`))
-    expect(errors).toEqual([])
-  })
-
-  it('should compile dynamic style', () => {
-    const { render, staticRenderFns, errors } = compile(`<div style="a: x; b: {{y}}"></div>`)
-    expect(render).not.toBeUndefined()
-    expect(staticRenderFns).toEqual([])
-    expect(render).toMatch(strToRegExp(`style:{a:"x",b:_s(y)}`))
-    expect(errors).not.toBeUndefined()
-    expect(errors.length).toEqual(1)
-    expect(errors[0]).toMatch(strToRegExp(`b: {{y}}`))
-    expect(errors[0]).toMatch(strToRegExp(`v-bind`))
-  })
-
-  it('should compile style binding of array', () => {
-    const { render, staticRenderFns, errors } = compile(`<div v-bind:style="[a, b, c]"></div>`)
-    expect(render).not.toBeUndefined()
-    expect(staticRenderFns).toEqual([])
-    expect(render).toMatch(strToRegExp(`style:[a, b, c]`))
-    expect(errors).toEqual([])
-  })
-
-  it('should compile style binding of map', () => {
-    const { render, staticRenderFns, errors } = compile(`<div v-bind:style="{ a: x, b: 'y' + z }"></div>`)
-    expect(render).not.toBeUndefined()
-    expect(staticRenderFns).toEqual([])
-    expect(render).toMatch(strToRegExp(`style:{ a: x, b: 'y' + z }`))
-    expect(errors).toEqual([])
-  })
-
-  it('should compile style binding of a variable', () => {
-    const { render, staticRenderFns, errors } = compile(`<div v-bind:style="x"></div>`)
-    expect(render).not.toBeUndefined()
-    expect(staticRenderFns).toEqual([])
-    expect(render).toMatch(strToRegExp(`style:x`))
-    expect(errors).toEqual([])
-  })
-
-  it('should compile style binding by shorthand', () => {
-    const { render, staticRenderFns, errors } = compile(`<div :style="[a, b, c]"></div>`)
-    expect(render).not.toBeUndefined()
-    expect(staticRenderFns).toEqual([])
-    expect(render).toMatch(strToRegExp(`style:[a, b, c]`))
-    expect(errors).toEqual([])
-  })
-})
diff --git a/1.Vue/test/weex/compiler/v-model.spec.js b/1.Vue/test/weex/compiler/v-model.spec.js
deleted file mode 100644
index c5f0401..0000000
--- a/1.Vue/test/weex/compiler/v-model.spec.js
+++ /dev/null
@@ -1,41 +0,0 @@
-import { compile } from '../../../packages/weex-template-compiler'
-import { strToRegExp } from '../helpers/index'
-
-describe('compile v-model', () => {
-  it('should compile modelable native component', () => {
-    const { render, staticRenderFns, errors } = compile(`<div><input v-model="x" /></div>`)
-    expect(render).not.toBeUndefined()
-    expect(render).toMatch(strToRegExp(`attrs:{"value":(x)}`))
-    expect(render).toMatch(strToRegExp(`on:{"input":function($event){x=$event.target.attr.value}}`))
-    expect(staticRenderFns).toEqual([])
-    expect(errors).toEqual([])
-  })
-
-  it('should compile other component with whole $event as the value', () => {
-    const { render, staticRenderFns, errors } = compile(`<div><foo v-model="x" /></div>`)
-    expect(render).not.toBeUndefined()
-    expect(render).toMatch(strToRegExp(`model:{value:(x),callback:function ($$v) {x=$$v},expression:"x"}`))
-    expect(staticRenderFns).toEqual([])
-    expect(errors).toEqual([])
-  })
-
-  it('should compile with trim modifier for modelable native component', () => {
-    const { render, staticRenderFns, errors } = compile(`<div><input v-model.trim="x" /></div>`)
-    expect(render).not.toBeUndefined()
-    expect(render).toMatch(strToRegExp(`attrs:{"value":(x)}`))
-    expect(render).toMatch(strToRegExp(`on:{"input":function($event){x=$event.target.attr.value.trim()}}`))
-    expect(staticRenderFns).toEqual([])
-    expect(errors).toEqual([])
-  })
-
-  it('should compile with trim & lazy modifier', () => {
-    const { render, staticRenderFns, errors } = compile(`<div><input v-model.trim.lazy="x" /><input v-model.lazy.trim="y" /></div>`)
-    expect(render).not.toBeUndefined()
-    expect(render).toMatch(strToRegExp(`attrs:{"value":(x)}`))
-    expect(render).toMatch(strToRegExp(`attrs:{"value":(y)}`))
-    expect(render).toMatch(strToRegExp(`on:{"change":function($event){x=$event.target.attr.value.trim()}}`))
-    expect(render).toMatch(strToRegExp(`on:{"change":function($event){y=$event.target.attr.value.trim()}}`))
-    expect(staticRenderFns).toEqual([])
-    expect(errors).toEqual([])
-  })
-})
diff --git a/1.Vue/test/weex/helpers/index.js b/1.Vue/test/weex/helpers/index.js
deleted file mode 100644
index ce74bf8..0000000
--- a/1.Vue/test/weex/helpers/index.js
+++ /dev/null
@@ -1,233 +0,0 @@
-import fs from 'fs'
-import path from 'path'
-import * as Vue from '../../../packages/weex-vue-framework'
-import { compile } from '../../../packages/weex-template-compiler'
-import WeexRuntime from 'weex-js-runtime'
-import styler from 'weex-styler'
-
-const styleRE = /<\s*style\s*\w*>([^(<\/)]*)<\/\s*style\s*>/g
-const scriptRE = /<\s*script.*>([^]*)<\/\s*script\s*>/
-const templateRE = /<\s*template\s*([^>]*)>([^]*)<\/\s*template\s*>/
-
-export function readFile (filename) {
-  return fs.readFileSync(path.resolve(__dirname, '../cases/', filename), 'utf8')
-}
-
-export function readObject (filename) {
-  return (new Function(`return ${readFile(filename)}`))()
-}
-
-console.debug = () => {}
-
-// http://stackoverflow.com/a/35478115
-const matchOperatorsRe = /[|\\{}()[\]^$+*?.]/g
-export function strToRegExp (str) {
-  return new RegExp(str.replace(matchOperatorsRe, '\\$&'))
-}
-
-function parseStatic (fns) {
-  return '[' + fns.map(fn => `function () { ${fn} }`).join(',') + ']'
-}
-
-export function compileAndStringify (template) {
-  const { render, staticRenderFns } = compile(template)
-  return {
-    render: `function () { ${render} }`,
-    staticRenderFns: parseStatic(staticRenderFns)
-  }
-}
-
-/**
- * Compile *.vue file into js code
- * @param {string} source raw text of *.vue file
- * @param {string} componentName whether compile to a component
- */
-export function compileVue (source, componentName) {
-  return new Promise((resolve, reject) => {
-    if (!templateRE.test(source)) {
-      return reject('No Template!')
-    }
-    const scriptMatch = scriptRE.exec(source)
-    const script = scriptMatch ? scriptMatch[1] : ''
-    const templateMatch = templateRE.exec(source)
-    const compileOptions = {}
-    if (/\s*recyclable\=?/i.test(templateMatch[1])) {
-      compileOptions.recyclable = true
-    }
-    const res = compile(templateMatch[2], compileOptions)
-
-    const name = 'test_case_' + (Math.random() * 99999999).toFixed(0)
-    const generateCode = styles => (`
-      try { weex.document.registerStyleSheets("${name}", [${JSON.stringify(styles)}]) } catch(e) {};
-      var ${name} = Object.assign({
-        _scopeId: "${name}",
-        style: ${JSON.stringify(styles)},
-        render: function () { ${res.render} },
-        ${res['@render'] ? ('"@render": function () {' + res['@render'] + '},') : ''}
-        staticRenderFns: ${parseStatic(res.staticRenderFns)},
-      }, (function(){
-        var module = { exports: {} };
-        ${script};
-        return module.exports;
-      })());
-    ` + (componentName
-        ? `Vue.component('${componentName}', ${name});\n`
-        : `${name}.el = 'body';new Vue(${name});`)
-    )
-
-    let cssText = ''
-    let styleMatch = null
-    while ((styleMatch = styleRE.exec(source))) {
-      cssText += `\n${styleMatch[1]}\n`
-    }
-    styler.parse(cssText, (error, result) => {
-      if (error) {
-        return reject(error)
-      }
-      resolve(generateCode(result.jsonStyle))
-    })
-    resolve(generateCode({}))
-  })
-}
-
-export function compileWithDeps (entryPath, deps) {
-  return new Promise((resolve, reject) => {
-    if (Array.isArray(deps)) {
-      Promise.all(deps.map(dep => {
-        return compileVue(readFile(dep.path), dep.name).catch(reject)
-      })).then(depCodes => {
-        compileVue(readFile(entryPath)).then(entryCode => {
-          resolve(depCodes.join('\n') + entryCode)
-        }).catch(reject)
-      }).catch(reject)
-    }
-  })
-}
-
-function isObject (object) {
-  return object !== null && typeof object === 'object'
-}
-
-function isEmptyObject (object) {
-  return isObject(object) && Object.keys(object).length < 1
-}
-
-function omitUseless (object) {
-  if (isObject(object)) {
-    delete object.ref
-    for (const key in object) {
-      omitUseless(object[key])
-      if (key === '@styleScope' ||
-        key === '@templateId' ||
-        key === 'bindingExpression') {
-        delete object[key]
-      }
-      if (key.charAt(0) !== '@' &&
-        (isEmptyObject(object[key]) || object[key] === undefined)) {
-        delete object[key]
-      }
-    }
-  }
-  return object
-}
-
-export function getRoot (instance) {
-  return omitUseless(instance.$getRoot())
-}
-
-// Get all binding events in the instance
-export function getEvents (instance) {
-  const events = []
-  const recordEvent = node => {
-    if (!node) { return }
-    if (Array.isArray(node.event)) {
-      node.event.forEach(type => {
-        events.push({ ref: node.ref, type })
-      })
-    }
-    if (Array.isArray(node.children)) {
-      node.children.forEach(recordEvent)
-    }
-  }
-  recordEvent(instance.$getRoot())
-  return events
-}
-
-export function fireEvent (instance, ref, type, event = {}) {
-  const el = instance.document.getRef(ref)
-  if (el) {
-    instance.document.fireEvent(el, type, event)
-  }
-}
-
-export function createInstance (id, code, ...args) {
-  WeexRuntime.config.frameworks = { Vue }
-  const context = WeexRuntime.init(WeexRuntime.config)
-  context.registerModules({
-    timer: ['setTimeout', 'setInterval']
-  })
-  const instance = context.createInstance(id, `// { "framework": "Vue" }\n${code}`, ...args) || {}
-  instance.document = context.getDocument(id)
-  instance.$getRoot = () => context.getRoot(id)
-  instance.$refresh = (data) => context.refreshInstance(id, data)
-  instance.$destroy = () => {
-    delete instance.document
-    context.destroyInstance(id)
-  }
-  instance.$triggerHook = (id, hook, args) => {
-    instance.document.taskCenter.triggerHook(id, 'lifecycle', hook, { args })
-  }
-  return instance
-}
-
-export function compileAndExecute (template, additional = '') {
-  return new Promise(resolve => {
-    const id = String(Date.now() * Math.random())
-    const { render, staticRenderFns } = compile(template)
-    const instance = createInstance(id, `
-      new Vue({
-        el: '#whatever',
-        render: function () { ${render} },
-        staticRenderFns: ${parseStatic(staticRenderFns)},
-        ${additional}
-      })
-    `)
-    setTimeout(() => resolve(instance), 10)
-  })
-}
-
-export function syncPromise (arr) {
-  let p = Promise.resolve()
-  arr.forEach(item => {
-    p = p.then(item)
-  })
-  return p
-}
-
-export function checkRefresh (instance, data, checker) {
-  return () => new Promise(res => {
-    instance.$refresh(data)
-    setTimeout(() => {
-      checker(getRoot(instance))
-      res()
-    })
-  })
-}
-
-export function addTaskHook (hook) {
-  global.callNative = function callNative (id, tasks) {
-    if (Array.isArray(tasks) && typeof hook === 'function') {
-      tasks.forEach(task => {
-        hook(id, {
-          module: task.module,
-          method: task.method,
-          args: Array.from(task.args)
-        })
-      })
-    }
-  }
-}
-
-export function resetTaskHook () {
-  delete global.callNative
-}
diff --git a/1.Vue/test/weex/jasmine.js b/1.Vue/test/weex/jasmine.js
deleted file mode 100644
index eaac309..0000000
--- a/1.Vue/test/weex/jasmine.js
+++ /dev/null
@@ -1,9 +0,0 @@
-module.exports = {
-  spec_dir: 'test/weex',
-  spec_files: [
-    '**/*[sS]pec.js'
-  ],
-  helpers: [
-    require.resolve('@babel/register')
-  ]
-}
diff --git a/1.Vue/test/weex/runtime/attrs.spec.js b/1.Vue/test/weex/runtime/attrs.spec.js
deleted file mode 100644
index 037067a..0000000
--- a/1.Vue/test/weex/runtime/attrs.spec.js
+++ /dev/null
@@ -1,89 +0,0 @@
-import { getRoot, fireEvent, compileAndExecute } from '../helpers/index'
-
-describe('generate attribute', () => {
-  it('should be generated', (done) => {
-    compileAndExecute(`
-      <div>
-        <text value="Hello World" style="font-size: 100"></text>
-      </div>
-    `).then(instance => {
-      expect(getRoot(instance)).toEqual({
-        type: 'div',
-        children: [{
-          type: 'text',
-          style: { fontSize: '100' },
-          attr: { value: 'Hello World' }
-        }]
-      })
-      done()
-    }).catch(e => done.fail(e))
-  })
-
-  it('should be updated', (done) => {
-    compileAndExecute(`
-      <div @click="foo">
-        <text :value="x"></text>
-      </div>
-    `, `
-      data: { x: 'Hello World' },
-      methods: {
-        foo: function () {
-          this.x = 'Hello Vue'
-        }
-      }
-    `).then(instance => {
-      expect(getRoot(instance)).toEqual({
-        type: 'div',
-        event: ['click'],
-        children: [
-          { type: 'text', attr: { value: 'Hello World' }}
-        ]
-      })
-      fireEvent(instance, '_root', 'click')
-      return instance
-    }).then(instance => {
-      expect(getRoot(instance)).toEqual({
-        type: 'div',
-        event: ['click'],
-        children: [
-          { type: 'text', attr: { value: 'Hello Vue' }}
-        ]
-      })
-      done()
-    }).catch(e => done.fail(e))
-  })
-
-  it('should be cleared', (done) => {
-    compileAndExecute(`
-      <div @click="foo">
-        <text :value="x"></text>
-      </div>
-    `, `
-      data: { x: 'Hello World' },
-      methods: {
-        foo: function () {
-          this.x = ''
-        }
-      }
-    `).then(instance => {
-      expect(getRoot(instance)).toEqual({
-        type: 'div',
-        event: ['click'],
-        children: [
-          { type: 'text', attr: { value: 'Hello World' }}
-        ]
-      })
-      fireEvent(instance, '_root', 'click')
-      return instance
-    }).then(instance => {
-      expect(getRoot(instance)).toEqual({
-        type: 'div',
-        event: ['click'],
-        children: [
-          { type: 'text', attr: { value: '' }}
-        ]
-      })
-      done()
-    })
-  })
-})
diff --git a/1.Vue/test/weex/runtime/class.spec.js b/1.Vue/test/weex/runtime/class.spec.js
deleted file mode 100644
index ec704f7..0000000
--- a/1.Vue/test/weex/runtime/class.spec.js
+++ /dev/null
@@ -1,161 +0,0 @@
-import { getRoot, fireEvent, compileAndExecute } from '../helpers/index'
-
-describe('generate class', () => {
-  it('should be generated', () => {
-    compileAndExecute(`
-      <div>
-        <text class="a b c">Hello World</text>
-      </div>
-    `, `
-      style: {
-        a: { fontSize: '100' },
-        b: { color: '#ff0000' },
-        c: { fontWeight: 'bold' }
-      }
-    `).then(instance => {
-      expect(getRoot(instance)).toEqual({
-        type: 'div',
-        children: [{
-          type: 'text',
-          classList: ['a', 'b', 'c'],
-          attr: { value: 'Hello World' }
-        }]
-      })
-    })
-  })
-
-  it('should be updated', (done) => {
-    compileAndExecute(`
-      <div @click="foo">
-        <text :class="['a', x]">Hello World</text>
-      </div>
-    `, `
-      data: { x: 'b' },
-      style: {
-        a: { fontSize: '100' },
-        b: { color: '#ff0000' },
-        c: { fontWeight: 'bold' },
-        d: {
-          color: '#0000ff',
-          fontWeight: 'bold'
-        }
-      },
-      methods: {
-        foo: function () {
-          this.x = 'd'
-        }
-      }
-    `).then(instance => {
-      expect(getRoot(instance)).toEqual({
-        type: 'div',
-        event: ['click'],
-        children: [{
-          type: 'text',
-          classList: ['a', 'b'],
-          attr: { value: 'Hello World' }
-        }]
-      })
-      fireEvent(instance, '_root', 'click')
-      return instance
-    }).then(instance => {
-      expect(getRoot(instance)).toEqual({
-        type: 'div',
-        event: ['click'],
-        children: [{
-          type: 'text',
-          classList: ['a', 'd'],
-          attr: { value: 'Hello World' }
-        }]
-      })
-      done()
-    })
-  })
-
-  it('should be applied in order', (done) => {
-    compileAndExecute(`
-      <div @click="foo">
-        <text :class="arr">Hello World</text>
-      </div>
-    `, `
-      data: {
-        arr: ['b', 'a']
-      },
-      style: {
-        a: { color: '#ff0000' },
-        b: { color: '#00ff00' },
-        c: { color: '#0000ff' }
-      },
-      methods: {
-        foo: function () {
-          this.arr.push('c')
-        }
-      }
-    `).then(instance => {
-      expect(getRoot(instance)).toEqual({
-        type: 'div',
-        event: ['click'],
-        children: [{
-          type: 'text',
-          classList: ['b', 'a'],
-          attr: { value: 'Hello World' }
-        }]
-      })
-      fireEvent(instance, '_root', 'click')
-      return instance
-    }).then(instance => {
-      expect(getRoot(instance)).toEqual({
-        type: 'div',
-        event: ['click'],
-        children: [{
-          type: 'text',
-          classList: ['b', 'a', 'c'],
-          attr: { value: 'Hello World' }
-        }]
-      })
-      done()
-    })
-  })
-
-  it('should be cleared', (done) => {
-    compileAndExecute(`
-      <div @click="foo">
-        <text :class="['a', x]">Hello World</text>
-      </div>
-    `, `
-      data: { x: 'b' },
-      style: {
-        a: { fontSize: '100' },
-        b: { color: '#ff0000' },
-        c: { fontWeight: 'bold' }
-      },
-      methods: {
-        foo: function () {
-          this.x = 'c'
-        }
-      }
-    `).then(instance => {
-      expect(getRoot(instance)).toEqual({
-        type: 'div',
-        event: ['click'],
-        children: [{
-          type: 'text',
-          classList: ['a', 'b'],
-          attr: { value: 'Hello World' }
-        }]
-      })
-      fireEvent(instance, '_root', 'click')
-      return instance
-    }).then(instance => {
-      expect(getRoot(instance)).toEqual({
-        type: 'div',
-        event: ['click'],
-        children: [{
-          type: 'text',
-          classList: ['a', 'c'],
-          attr: { value: 'Hello World' }
-        }]
-      })
-      done()
-    })
-  })
-})
diff --git a/1.Vue/test/weex/runtime/components/richtext.spec.js b/1.Vue/test/weex/runtime/components/richtext.spec.js
deleted file mode 100644
index 7d10498..0000000
--- a/1.Vue/test/weex/runtime/components/richtext.spec.js
+++ /dev/null
@@ -1,692 +0,0 @@
-import {
-  compileAndStringify,
-  getRoot,
-  fireEvent,
-  createInstance
-} from '../../helpers/index'
-
-function compileSnippet (snippet, additional) {
-  const { render, staticRenderFns } = compileAndStringify(`<div>${snippet}</div>`)
-  const id = String(Date.now() * Math.random())
-  const instance = createInstance(id, `
-    new Vue({
-      el: 'body',
-      render: ${render},
-      staticRenderFns: ${staticRenderFns},
-      ${additional}
-    })
-  `)
-  return getRoot(instance).children[0]
-}
-
-describe('richtext component', () => {
-  it('with no child', () => {
-    expect(compileSnippet(`
-      <richtext></richtext>
-    `)).toEqual({
-      type: 'richtext'
-    })
-  })
-
-  it('with single text node', () => {
-    expect(compileSnippet(`
-      <richtext>single</richtext>
-    `)).toEqual({
-      type: 'richtext',
-      attr: {
-        value: [{
-          type: 'span',
-          attr: {
-            value: 'single'
-          }
-        }]
-      }
-    })
-  })
-
-  describe('span', () => {
-    it('single node', () => {
-      expect(compileSnippet(`
-        <richtext>
-          <span>single</span>
-        </richtext>
-      `)).toEqual({
-        type: 'richtext',
-        attr: {
-          value: [{
-            type: 'span',
-            attr: {
-              value: 'single'
-            }
-          }]
-        }
-      })
-    })
-
-    it('multiple node', () => {
-      expect(compileSnippet(`
-        <richtext>
-          <span>AAA</span>
-          <span>BBB</span>
-        </richtext>
-      `)).toEqual({
-        type: 'richtext',
-        attr: {
-          value: [{
-            type: 'span',
-            attr: { value: 'AAA' }
-          }, {
-            type: 'span',
-            attr: { value: 'BBB' }
-          }]
-        }
-      })
-    })
-
-    it('with raw text', () => {
-      expect(compileSnippet(`
-        <richtext>
-          AAA
-          <span>BBB</span>CCC
-          <span>DDD</span>
-        </richtext>
-      `)).toEqual({
-        type: 'richtext',
-        attr: {
-          value: [{
-            type: 'span',
-            attr: { value: 'AAA' }
-          }, {
-            type: 'span',
-            attr: { value: 'BBB' }
-          }, {
-            type: 'span',
-            attr: { value: 'CCC' }
-          }, {
-            type: 'span',
-            attr: { value: 'DDD' }
-          }]
-        }
-      })
-    })
-  })
-
-  describe('a', () => {
-    it('single node', () => {
-      expect(compileSnippet(`
-        <richtext>
-          <a href="http://whatever.com"></a>
-        </richtext>
-      `)).toEqual({
-        type: 'richtext',
-        attr: {
-          value: [{
-            type: 'a',
-            attr: { href: 'http://whatever.com' }
-          }]
-        }
-      })
-    })
-
-    it('multiple node', () => {
-      expect(compileSnippet(`
-        <richtext>
-          <a href="http://a.whatever.com"></a>
-          <a href="http://b.whatever.com"></a>
-        </richtext>
-      `)).toEqual({
-        type: 'richtext',
-        attr: {
-          value: [{
-            type: 'a',
-            attr: { href: 'http://a.whatever.com' }
-          }, {
-            type: 'a',
-            attr: { href: 'http://b.whatever.com' }
-          }]
-        }
-      })
-    })
-  })
-
-  describe('image', () => {
-    it('single node', () => {
-      expect(compileSnippet(`
-        <richtext>
-          <image src="path/to/profile.png"></image>
-        </richtext>
-      `)).toEqual({
-        type: 'richtext',
-        attr: {
-          value: [{
-            type: 'image',
-            attr: { src: 'path/to/profile.png' }
-          }]
-        }
-      })
-    })
-
-    it('multiple node', () => {
-      expect(compileSnippet(`
-        <richtext>
-          <image src="path/to/A.png"></image>
-          <image src="path/to/B.png"></image>
-        </richtext>
-      `)).toEqual({
-        type: 'richtext',
-        attr: {
-          value: [{
-            type: 'image',
-            attr: { src: 'path/to/A.png' }
-          }, {
-            type: 'image',
-            attr: { src: 'path/to/B.png' }
-          }]
-        }
-      })
-    })
-
-    it('with width and height', () => {
-      expect(compileSnippet(`
-        <richtext>
-          <image
-            style="width:150px;height:150px;"
-            src="path/to/profile.png">
-          </image>
-        </richtext>
-      `)).toEqual({
-        type: 'richtext',
-        attr: {
-          value: [{
-            type: 'image',
-            style: { width: '150px', height: '150px' },
-            attr: { src: 'path/to/profile.png' }
-          }]
-        }
-      })
-    })
-  })
-
-  describe('nested', () => {
-    it('span', () => {
-      expect(compileSnippet(`
-        <richtext>
-          <span>AAA
-            <span>
-              <span>BBB</span>
-              <span><span>CCC</span>DDD</span>
-            </span>
-          </span>
-        </richtext>
-      `)).toEqual({
-        type: 'richtext',
-        attr: {
-          value: [{
-            type: 'span',
-            children: [{
-              type: 'span',
-              attr: { value: 'AAA' }
-            }, {
-              type: 'span',
-              children: [{
-                type: 'span',
-                attr: { value: 'BBB' }
-              }, {
-                type: 'span',
-                children: [{
-                  type: 'span',
-                  attr: { value: 'CCC' }
-                }, {
-                  type: 'span',
-                  attr: { value: 'DDD' }
-                }]
-              }]
-            }]
-          }]
-        }
-      })
-    })
-
-    it('image and a', () => {
-      expect(compileSnippet(`
-        <richtext>
-          <span>title</span>
-          <a href="http://remote.com/xx.js">
-            <span><span>name</span></span>
-            <image src="path/to/yy.gif"></image>
-          </a>
-        </richtext>
-      `)).toEqual({
-        type: 'richtext',
-        attr: {
-          value: [{
-            type: 'span',
-            attr: { value: 'title' }
-          }, {
-            type: 'a',
-            attr: { href: 'http://remote.com/xx.js' },
-            children: [{
-              type: 'span',
-              children: [{
-                type: 'span',
-                attr: { value: 'name' }
-              }]
-            }, {
-              type: 'image',
-              attr: { src: 'path/to/yy.gif' }
-            }]
-          }]
-        }
-      })
-    })
-  })
-
-  describe('with styles', () => {
-    it('inline', () => {
-      expect(compileSnippet(`
-        <richtext>
-          <span style="font-size:16px;color:#FF6600;">ABCD</span>
-          <image style="width:33.33px;height:66.67px" src="path/to/A.png"></image>
-        </richtext>
-      `)).toEqual({
-        type: 'richtext',
-        attr: {
-          value: [{
-            type: 'span',
-            style: { fontSize: '16px', color: '#FF6600' },
-            attr: { value: 'ABCD' }
-          }, {
-            type: 'image',
-            style: { width: '33.33px', height: '66.67px' },
-            attr: { src: 'path/to/A.png' }
-          }]
-        }
-      })
-    })
-
-    it('class list', () => {
-      expect(compileSnippet(`
-        <richtext>
-          <image class="icon" src="path/to/A.png"></image>
-          <span class="title large">ABCD</span>
-        </richtext>
-      `, `
-        style: {
-          title: { color: '#FF6600' },
-          large: { fontSize: 24 },
-          icon: { width: 40, height: 60 }
-        }
-      `)).toEqual({
-        type: 'richtext',
-        attr: {
-          value: [{
-            type: 'image',
-            style: { width: 40, height: 60 },
-            attr: { src: 'path/to/A.png' }
-          }, {
-            type: 'span',
-            style: { fontSize: 24, color: '#FF6600' },
-            attr: { value: 'ABCD' }
-          }]
-        }
-      })
-    })
-  })
-
-  describe('data binding', () => {
-    it('simple', () => {
-      expect(compileSnippet(`
-        <richtext>
-          <span>{{name}}</span>
-        </richtext>
-      `, `data: { name: 'ABCDEFG' }`)).toEqual({
-        type: 'richtext',
-        attr: {
-          value: [{
-            type: 'span',
-            attr: { value: 'ABCDEFG' }
-          }]
-        }
-      })
-    })
-
-    it('nested', () => {
-      expect(compileSnippet(`
-        <richtext>
-          <span>{{a}}</span>
-          <span>{{b}}<span>{{c.d}}</span></span>
-          <span>{{e}}</span>
-        </richtext>
-      `, `
-        data: { a: 'A', b: 'B', c: { d: 'CD' }, e: 'E' }
-      `)).toEqual({
-        type: 'richtext',
-        attr: {
-          value: [{
-            type: 'span',
-            attr: { value: 'A' }
-          }, {
-            type: 'span',
-            children: [{
-              type: 'span',
-              attr: { value: 'B' }
-            }, {
-              type: 'span',
-              attr: { value: 'CD' }
-            }]
-          }, {
-            type: 'span',
-            attr: { value: 'E' }
-          }]
-        }
-      })
-    })
-
-    it('update', () => {
-      expect(compileSnippet(`
-        <richtext>
-          <span>{{name}}</span>
-        </richtext>
-      `, `
-        data: { name: 'default' },
-        created: function () {
-          this.name = 'updated'
-        }
-      `)).toEqual({
-        type: 'richtext',
-        attr: {
-          value: [{
-            type: 'span',
-            attr: { value: 'updated' }
-          }]
-        }
-      })
-    })
-
-    it('attribute', () => {
-      expect(compileSnippet(`
-        <richtext>
-          <span :label="label">{{name}}</span>
-        </richtext>
-      `, `
-        data: {
-          label: 'uid',
-          name: '10100'
-        }
-      `)).toEqual({
-        type: 'richtext',
-        attr: {
-          value: [{
-            type: 'span',
-            attr: {
-              label: 'uid',
-              value: '10100'
-            }
-          }]
-        }
-      })
-    })
-
-    it('update attribute', () => {
-      expect(compileSnippet(`
-        <richtext>
-          <span :label="label">{{name}}</span>
-        </richtext>
-      `, `
-        data: {
-          label: 'name',
-          name: 'Hanks'
-        },
-        created: function () {
-          this.label = 'uid';
-          this.name = '10100';
-        }
-      `)).toEqual({
-        type: 'richtext',
-        attr: {
-          value: [{
-            type: 'span',
-            attr: {
-              label: 'uid',
-              value: '10100'
-            }
-          }]
-        }
-      })
-    })
-
-    it('inline style', () => {
-      expect(compileSnippet(`
-        <richtext>
-          <span :style="styleObject">ABCD</span>
-          <span :style="{ textAlign: align, color: 'red' }">EFGH</span>
-        </richtext>
-      `, `
-        data: {
-          styleObject: { fontSize: '32px', color: '#F6F660' },
-          align: 'center'
-        }
-      `)).toEqual({
-        type: 'richtext',
-        attr: {
-          value: [{
-            type: 'span',
-            style: { fontSize: '32px', color: '#F6F660' },
-            attr: { value: 'ABCD' }
-          }, {
-            type: 'span',
-            style: { textAlign: 'center', color: 'red' },
-            attr: { value: 'EFGH' }
-          }]
-        }
-      })
-    })
-
-    it('class list', () => {
-      expect(compileSnippet(`
-        <richtext>
-          <image :class="classList" src="path/to/A.png"></image>
-          <span :class="['title', size]">ABCD</span>
-          <span class="large" style="color:#F6F0F4">EFGH</span>
-        </richtext>
-      `, `
-        style: {
-          title: { color: '#FF6600' },
-          large: { fontSize: 24 },
-          icon: { width: 40, height: 60 }
-        },
-        data: {
-          classList: ['unknown'],
-          size: 'small'
-        },
-        created: function () {
-          this.classList = ['icon'];
-          this.size = 'large';
-        }
-      `)).toEqual({
-        type: 'richtext',
-        attr: {
-          value: [{
-            type: 'image',
-            style: { width: 40, height: 60 },
-            attr: { src: 'path/to/A.png' }
-          }, {
-            type: 'span',
-            style: { fontSize: 24, color: '#FF6600' },
-            attr: { value: 'ABCD' }
-          }, {
-            type: 'span',
-            style: { fontSize: 24, color: '#F6F0F4' },
-            attr: { value: 'EFGH' }
-          }]
-        }
-      })
-    })
-
-    it('update inline style', () => {
-      expect(compileSnippet(`
-        <richtext>
-          <span :style="styleObject">ABCD</span>
-          <span :style="{ textAlign: align, color: 'red' }">EFGH</span>
-        </richtext>
-      `, `
-        data: {
-          styleObject: { fontSize: '32px', color: '#F6F660' }
-        },
-        created: function () {
-          this.styleObject = { fontSize: '24px', color: 'blue' }
-          this.styleObject.color = '#ABCDEF'
-          this.align = 'left'
-        }
-      `)).toEqual({
-        type: 'richtext',
-        attr: {
-          value: [{
-            type: 'span',
-            style: { fontSize: '24px', color: '#ABCDEF' },
-            attr: { value: 'ABCD' }
-          }, {
-            type: 'span',
-            style: { textAlign: 'left', color: 'red' },
-            attr: { value: 'EFGH' }
-          }]
-        }
-      })
-    })
-  })
-
-  describe('itself', () => {
-    it('inline styles', () => {
-      expect(compileSnippet(`
-        <richtext style="background-color:red">
-          <span>empty</span>
-        </richtext>
-      `)).toEqual({
-        type: 'richtext',
-        style: { backgroundColor: 'red' },
-        attr: {
-          value: [{
-            type: 'span',
-            attr: { value: 'empty' }
-          }]
-        }
-      })
-    })
-
-    it('class list', () => {
-      expect(compileSnippet(`
-        <richtext class="title">
-          <span class="large">ABCD</span>
-        </richtext>
-      `, `
-        style: {
-          title: { backgroundColor: '#FF6600', height: 200 },
-          large: { fontSize: 24 }
-        }
-      `)).toEqual({
-        type: 'richtext',
-        classList: ['title'],
-        attr: {
-          value: [{
-            type: 'span',
-            style: { fontSize: 24 },
-            attr: { value: 'ABCD' }
-          }]
-        }
-      })
-    })
-
-    it('update styles', () => {
-      expect(compileSnippet(`
-        <richtext :class="classList" :style="{ backgroundColor: color }">
-          <span class="large">ABCD</span>
-        </richtext>
-      `, `
-        data: { classList: ['unknow'], color: '#FF6600' },
-        style: {
-          title: { height: 200 },
-          large: { fontSize: 24 }
-        },
-        created: function () {
-          this.classList = ['title']
-        }
-      `)).toEqual({
-        type: 'richtext',
-        classList: ['title'],
-        style: { backgroundColor: '#FF6600' },
-        attr: {
-          value: [{
-            type: 'span',
-            style: { fontSize: 24 },
-            attr: { value: 'ABCD' }
-          }]
-        }
-      })
-    })
-
-    it('bind events', (done) => {
-      const { render, staticRenderFns } = compileAndStringify(`
-        <div>
-          <richtext @click="handler">
-            <span>Label: {{label}}</span>
-          </richtext>
-        </div>
-      `)
-      const id = String(Date.now() * Math.random())
-      const instance = createInstance(id, `
-        new Vue({
-          el: 'body',
-          render: ${render},
-          staticRenderFns: ${staticRenderFns},
-          data: { label: 'AAA' },
-          methods: {
-            handler: function () {
-              this.label = 'BBB'
-            }
-          }
-        })
-      `)
-      const richtext = instance.document.body.children[0]
-      fireEvent(instance, richtext.ref, 'click')
-      setTimeout(() => {
-        expect(getRoot(instance).children[0]).toEqual({
-          type: 'richtext',
-          event: ['click'],
-          attr: {
-            value: [{
-              type: 'span',
-              attr: { value: 'Label: BBB' }
-            }]
-          }
-        })
-        done()
-      }, 0)
-    })
-
-    it('v-for', () => {
-      expect(compileSnippet(`
-        <div>
-          <richtext v-for="k in labels">
-            <span>{{k}}</span>
-          </richtext>
-        </div>
-      `, `
-        data: {
-          labels: ['A', 'B', 'C']
-        }
-      `)).toEqual({
-        type: 'div',
-        children: [{
-          type: 'richtext',
-          attr: { value: [{ type: 'span', attr: { value: 'A' }}] }
-        }, {
-          type: 'richtext',
-          attr: { value: [{ type: 'span', attr: { value: 'B' }}] }
-        }, {
-          type: 'richtext',
-          attr: { value: [{ type: 'span', attr: { value: 'C' }}] }
-        }]
-      })
-    })
-  })
-})
diff --git a/1.Vue/test/weex/runtime/events.spec.js b/1.Vue/test/weex/runtime/events.spec.js
deleted file mode 100644
index 79ddbdb..0000000
--- a/1.Vue/test/weex/runtime/events.spec.js
+++ /dev/null
@@ -1,98 +0,0 @@
-import { getRoot, fireEvent, compileAndStringify, compileAndExecute } from '../helpers/index'
-
-describe('generate events', () => {
-  it('should be bound and fired for native component', (done) => {
-    compileAndExecute(`
-      <div @click="foo">
-        <text>Hello {{x}}</text>
-      </div>
-    `, `
-      data: { x: 'World' },
-      methods: {
-        foo: function () {
-          this.x = 'Weex'
-        }
-      }
-    `).then(instance => {
-      expect(getRoot(instance)).toEqual({
-        type: 'div',
-        event: ['click'],
-        children: [{
-          type: 'text',
-          attr: { value: 'Hello World' }
-        }]
-      })
-      fireEvent(instance, '_root', 'click')
-      return instance
-    }).then(instance => {
-      expect(getRoot(instance)).toEqual({
-        type: 'div',
-        event: ['click'],
-        children: [{
-          type: 'text',
-          attr: { value: 'Hello Weex' }
-        }]
-      })
-      done()
-    })
-  })
-
-  it('should be bound and fired by custom component', (done) => {
-    const { render, staticRenderFns } = compileAndStringify(`<text>Hello {{x}}</text>`)
-    compileAndExecute(`
-      <div>
-        <text>Hello {{x}}</text>
-        <sub @click="foo" @click.native="bar"></sub>
-      </div>
-    `, `
-      data: { x: 'World' },
-      components: {
-        sub: {
-          data: function () {
-            return { x: 'Sub' }
-          },
-          render: ${render},
-          staticRenderFns: ${staticRenderFns},
-          created: function () {
-            this.$emit('click')
-          }
-        }
-      },
-      methods: {
-        foo: function () {
-          this.x = 'Foo'
-        },
-        bar: function () {
-          this.x = 'Bar'
-        }
-      }
-    `).then(instance => {
-      expect(getRoot(instance)).toEqual({
-        type: 'div',
-        children: [{
-          type: 'text',
-          attr: { value: 'Hello Foo' }
-        }, {
-          type: 'text',
-          event: ['click'],
-          attr: { value: 'Hello Sub' }
-        }]
-      })
-      fireEvent(instance, instance.document.body.children[1].ref, 'click')
-      return instance
-    }).then(instance => {
-      expect(getRoot(instance)).toEqual({
-        type: 'div',
-        children: [{
-          type: 'text',
-          attr: { value: 'Hello Bar' }
-        }, {
-          type: 'text',
-          event: ['click'],
-          attr: { value: 'Hello Sub' }
-        }]
-      })
-      done()
-    })
-  })
-})
diff --git a/1.Vue/test/weex/runtime/framework.spec.js b/1.Vue/test/weex/runtime/framework.spec.js
deleted file mode 100644
index ac74680..0000000
--- a/1.Vue/test/weex/runtime/framework.spec.js
+++ /dev/null
@@ -1,194 +0,0 @@
-import { getRoot, createInstance } from '../helpers/index'
-
-describe('framework APIs', () => {
-  it('createInstance', () => {
-    const id = String(Date.now() * Math.random())
-    const instance = createInstance(id, `
-      new Vue({
-        render: function (createElement) {
-          return createElement('div', {}, [
-            createElement('text', { attrs: { value: 'Hello' }}, [])
-          ])
-        },
-        el: "body"
-      })
-    `)
-    expect(getRoot(instance)).toEqual({
-      type: 'div',
-      children: [{ type: 'text', attr: { value: 'Hello' }}]
-    })
-  })
-
-  it('createInstance with config', () => {
-    const id = String(Date.now() * Math.random())
-    const instance = createInstance(id, `
-      new Vue({
-        render: function (createElement) {
-          return createElement('div', {}, [
-            createElement('text', { attrs: { value: JSON.stringify(weex.config) }}, [])
-          ])
-        },
-        el: "body"
-      })
-    `, { bundleType: 'Vue', bundleUrl: 'http://example.com/', a: 1, b: 2 })
-    expect(getRoot(instance)).toEqual({
-      type: 'div',
-      children: [{
-        type: 'text',
-        attr: { value: '{"bundleType":"Vue","bundleUrl":"http://example.com/","a":1,"b":2,"env":{}}' }
-      }]
-    })
-  })
-
-  it('createInstance with external data', () => {
-    const id = String(Date.now() * Math.random())
-    const instance = createInstance(id, `
-      new Vue({
-        data: {
-          a: 1,
-          b: 2
-        },
-        render: function (createElement) {
-          return createElement('div', {}, [
-            createElement('text', { attrs: { value: this.a + '-' + this.b }}, [])
-          ])
-        },
-        el: "body"
-      })
-    `, undefined, { a: 111 })
-    expect(getRoot(instance)).toEqual({
-      type: 'div',
-      children: [{ type: 'text', attr: { value: '111-2' }}]
-    })
-  })
-
-  it('destroyInstance', (done) => {
-    const id = String(Date.now() * Math.random())
-    const instance = createInstance(id, `
-      new Vue({
-        data: {
-          x: 'Hello'
-        },
-        render: function (createElement) {
-          return createElement('div', {}, [
-            createElement('text', { attrs: { value: this.x }}, [])
-          ])
-        },
-        el: "body"
-      })
-    `)
-    expect(getRoot(instance)).toEqual({
-      type: 'div',
-      children: [{ type: 'text', attr: { value: 'Hello' }}]
-    })
-    instance.$destroy()
-    setTimeout(() => {
-      expect(instance.document).toBeUndefined()
-      expect(instance.app).toBeUndefined()
-      done()
-    }, 0)
-  })
-
-  it('refreshInstance', (done) => {
-    const id = String(Date.now() * Math.random())
-    const instance = createInstance(id, `
-      new Vue({
-        data: {
-          x: 'Hello'
-        },
-        render: function (createElement) {
-          return createElement('div', {}, [
-            createElement('text', { attrs: { value: this.x }}, [])
-          ])
-        },
-        el: "body"
-      })
-    `)
-    expect(getRoot(instance)).toEqual({
-      type: 'div',
-      children: [{ type: 'text', attr: { value: 'Hello' }}]
-    })
-    instance.$refresh({ x: 'World' })
-    setTimeout(() => {
-      expect(getRoot(instance)).toEqual({
-        type: 'div',
-        children: [{ type: 'text', attr: { value: 'World' }}]
-      })
-      instance.$destroy()
-      const result = instance.$refresh({ x: 'World' })
-      expect(result instanceof Error).toBe(true)
-      done()
-    })
-  })
-
-  it('registering global assets', () => {
-    const id = String(Date.now() * Math.random())
-    const instance = createInstance(id, `
-      Vue.component('test', {
-        render (h) {
-          return h('div', 'Hello')
-        }
-      })
-      new Vue({
-        render (h) {
-          return h('test')
-        },
-        el: 'body'
-      })
-    `)
-    expect(getRoot(instance)).toEqual({
-      type: 'div',
-      children: [{ type: 'text', attr: { value: 'Hello' }}]
-    })
-  })
-
-  it('adding prototype methods', () => {
-    const id = String(Date.now() * Math.random())
-    const instance = createInstance(id, `
-      Vue.prototype.$test = () => 'Hello'
-      const Test = {
-        render (h) {
-          return h('div', this.$test())
-        }
-      }
-      new Vue({
-        render (h) {
-          return h(Test)
-        },
-        el: 'body'
-      })
-    `)
-    expect(getRoot(instance)).toEqual({
-      type: 'div',
-      children: [{ type: 'text', attr: { value: 'Hello' }}]
-    })
-  })
-
-  it('using global mixins', () => {
-    const id = String(Date.now() * Math.random())
-    const instance = createInstance(id, `
-      Vue.mixin({
-        created () {
-          this.test = true
-        }
-      })
-      const Test = {
-        data: () => ({ test: false }),
-        render (h) {
-          return h('div', this.test ? 'Hello' : 'nope')
-        }
-      }
-      new Vue({
-        data: { test: false },
-        render (h) {
-          return this.test ? h(Test) : h('p')
-        },
-        el: 'body'
-      })
-    `)
-    expect(getRoot(instance)).toEqual({
-      type: 'div',
-      children: [{ type: 'text', attr: { value: 'Hello' }}]
-    })
-  })
-})
diff --git a/1.Vue/test/weex/runtime/node.spec.js b/1.Vue/test/weex/runtime/node.spec.js
deleted file mode 100644
index 06a20c6..0000000
--- a/1.Vue/test/weex/runtime/node.spec.js
+++ /dev/null
@@ -1,513 +0,0 @@
-import {
-  compileAndStringify,
-  createInstance,
-  getRoot,
-  syncPromise,
-  checkRefresh
-} from '../helpers/index'
-
-describe('node in render function', () => {
-  it('should be generated', () => {
-    const id = String(Date.now() * Math.random())
-    const instance = createInstance(id, `
-      new Vue({
-        render: function (createElement) {
-          return createElement('div', {}, [
-            createElement('text', { attrs: { value: 'Hello' }}, [])
-          ])
-        },
-        el: "body"
-      })
-    `)
-    expect(getRoot(instance)).toEqual({
-      type: 'div',
-      children: [
-        { type: 'text', attr: { value: 'Hello' }}
-      ]
-    })
-  })
-
-  it('should be generated with all types of text', () => {
-    const id = String(Date.now() * Math.random())
-    const instance = createInstance(id, `
-      new Vue({
-        render: function (createElement) {
-          return createElement('div', {}, [
-            createElement('text', { attrs: { value: 'Hello' }}, []),
-            'World',
-            createElement('text', {}, ['Weex'])
-          ])
-        },
-        el: "body"
-      })
-    `)
-    expect(getRoot(instance)).toEqual({
-      type: 'div',
-      children: [
-        { type: 'text', attr: { value: 'Hello' }},
-        { type: 'text', attr: { value: 'World' }},
-        { type: 'text', attr: { value: 'Weex' }}
-      ]
-    })
-  })
-
-  it('should be generated with comments', () => {
-    // todo
-  })
-
-  it('should be generated with module diff', (done) => {
-    const id = String(Date.now() * Math.random())
-    const instance = createInstance(id, `
-      new Vue({
-        data: {
-          counter: 0
-        },
-        methods: {
-          foo: function () {}
-        },
-        render: function (createElement) {
-          switch (this.counter) {
-            case 1:
-            return createElement('div', {}, [
-              createElement('text', { attrs: { value: 'World' }}, [])
-            ])
-
-            case 2:
-            return createElement('div', {}, [
-              createElement('text', { attrs: { value: 'World' }, style: { fontSize: 100 }}, [])
-            ])
-
-            case 3:
-            return createElement('div', {}, [
-              createElement('text', {
-                attrs: { value: 'World' },
-                style: { fontSize: 100 },
-                on: { click: this.foo }
-              }, [])
-            ])
-
-            case 4:
-            return createElement('div', {}, [
-              createElement('text', {
-                attrs: { value: 'Weex' },
-                style: { color: '#ff0000' }
-              }, [])
-            ])
-
-            default:
-            return createElement('div', {}, [
-              createElement('text', { attrs: { value: 'Hello' }}, [])
-            ])
-          }
-        },
-        el: "body"
-      })
-    `)
-    expect(getRoot(instance)).toEqual({
-      type: 'div',
-      children: [
-        { type: 'text', attr: { value: 'Hello' }}
-      ]
-    })
-
-    syncPromise([
-      checkRefresh(instance, { counter: 1 }, result => {
-        expect(result).toEqual({
-          type: 'div',
-          children: [
-            { type: 'text', attr: { value: 'World' }}
-          ]
-        })
-      }),
-      checkRefresh(instance, { counter: 2 }, result => {
-        expect(result).toEqual({
-          type: 'div',
-          children: [
-            { type: 'text', attr: { value: 'World' }, style: { fontSize: 100 }}
-          ]
-        })
-      }),
-      checkRefresh(instance, { counter: 3 }, result => {
-        expect(result).toEqual({
-          type: 'div',
-          children: [
-            { type: 'text', attr: { value: 'World' }, style: { fontSize: 100 }, event: ['click'] }
-          ]
-        })
-      }),
-      checkRefresh(instance, { counter: 4 }, result => {
-        expect(result).toEqual({
-          type: 'div',
-          children: [
-            { type: 'text', attr: { value: 'Weex' }, style: { fontSize: '', color: '#ff0000' }}
-          ]
-        })
-        done()
-      })
-    ])
-  })
-
-  it('should be generated with sub components', () => {
-    const id = String(Date.now() * Math.random())
-    const instance = createInstance(id, `
-      new Vue({
-        render: function (createElement) {
-          return createElement('div', {}, [
-            createElement('text', { attrs: { value: 'Hello' }}, []),
-            createElement('foo', { props: { x: 'Weex' }})
-          ])
-        },
-        components: {
-          foo: {
-            props: {
-              x: { default: 'World' }
-            },
-            render: function (createElement) {
-              return createElement('text', { attrs: { value: this.x }}, [])
-            }
-          }
-        },
-        el: "body"
-      })
-    `)
-    expect(getRoot(instance)).toEqual({
-      type: 'div',
-      children: [
-        { type: 'text', attr: { value: 'Hello' }},
-        { type: 'text', attr: { value: 'Weex' }}
-      ]
-    })
-  })
-
-  it('should be generated with if/for diff', (done) => {
-    const { render, staticRenderFns } = compileAndStringify(`
-      <div>
-        <text v-for="item in list" v-if="item.x">{{item.v}}</text>
-      </div>
-    `)
-    const id = String(Date.now() * Math.random())
-    const instance = createInstance(id, `
-      new Vue({
-        data: {
-          list: [
-            { v: 'Hello', x: true },
-            { v: 'World', x: false },
-            { v: 'Weex', x: true }
-          ]
-        },
-        computed: {
-          x: {
-            get: function () { return 0 },
-            set: function (v) {
-              switch (v) {
-                case 1:
-                this.list[1].x = true
-                break
-                case 2:
-                this.list.push({ v: 'v-if' })
-                break
-                case 3:
-                this.list.push({ v: 'v-for', x: true })
-                break
-                case 4:
-                this.list.splice(1, 2)
-                break
-              }
-            }
-          }
-        },
-        render: ${render},
-        staticRenderFns: ${staticRenderFns},
-        el: "body"
-      })
-    `)
-    expect(getRoot(instance)).toEqual({
-      type: 'div',
-      children: [
-        { type: 'text', attr: { value: 'Hello' }},
-        { type: 'text', attr: { value: 'Weex' }}
-      ]
-    })
-
-    syncPromise([
-      checkRefresh(instance, { x: 1 }, result => {
-        expect(result).toEqual({
-          type: 'div',
-          children: [
-            { type: 'text', attr: { value: 'Hello' }},
-            { type: 'text', attr: { value: 'World' }},
-            { type: 'text', attr: { value: 'Weex' }}
-          ]
-        })
-      }),
-      checkRefresh(instance, { x: 2 }, result => {
-        expect(result).toEqual({
-          type: 'div',
-          children: [
-            { type: 'text', attr: { value: 'Hello' }},
-            { type: 'text', attr: { value: 'World' }},
-            { type: 'text', attr: { value: 'Weex' }}
-          ]
-        })
-      }),
-      checkRefresh(instance, { x: 3 }, result => {
-        expect(result).toEqual({
-          type: 'div',
-          children: [
-            { type: 'text', attr: { value: 'Hello' }},
-            { type: 'text', attr: { value: 'World' }},
-            { type: 'text', attr: { value: 'Weex' }},
-            { type: 'text', attr: { value: 'v-for' }}
-          ]
-        })
-      }),
-      checkRefresh(instance, { x: 4 }, result => {
-        expect(result).toEqual({
-          type: 'div',
-          children: [
-            { type: 'text', attr: { value: 'Hello' }},
-            { type: 'text', attr: { value: 'v-for' }}
-          ]
-        })
-        done()
-      })
-    ])
-  })
-
-  it('should be generated with node structure diff', (done) => {
-    const id = String(Date.now() * Math.random())
-    const instance = createInstance(id, `
-      new Vue({
-        data: {
-          counter: 0
-        },
-        render: function (createElement) {
-          switch (this.counter) {
-            case 1:
-            return createElement('div', {}, [
-              createElement('text', { attrs: { value: 'Hello' }}, []),
-              createElement('text', { attrs: { value: 'World' }}, [])
-            ])
-
-            case 2:
-            return createElement('div', {}, [
-              createElement('text', { attrs: { value: 'Hello' }}, []),
-              createElement('text', { attrs: { value: 'World' }}, []),
-              createElement('text', { attrs: { value: 'Weex' }}, [])
-            ])
-
-            case 3:
-            return createElement('div', {}, [
-              createElement('text', { attrs: { value: 'Hello' }}, []),
-              createElement('text', { attrs: { value: 'Weex' }}, [])
-            ])
-
-            case 4:
-            return createElement('div', {}, [
-              createElement('text', { attrs: { value: 'Weex' }}, [])
-            ])
-
-            case 5:
-            return createElement('div', {}, [
-              createElement('text', { attrs: { value: 'Hello' }}, []),
-              createElement('text', { attrs: { value: 'Weex' }}, [])
-            ])
-
-            case 6:
-            return createElement('div', {}, [
-              createElement('input', { attrs: { value: 'Hello' }}, []),
-              createElement('text', { attrs: { value: 'Weex' }}, [])
-            ])
-
-            default:
-            return createElement('div', {}, [
-              createElement('text', { attrs: { value: 'Hello' }}, []),
-            ])
-          }
-        },
-        el: "body"
-      })
-    `)
-    expect(getRoot(instance)).toEqual({
-      type: 'div',
-      children: [
-        { type: 'text', attr: { value: 'Hello' }}
-      ]
-    })
-
-    syncPromise([
-      checkRefresh(instance, { counter: 1 }, result => {
-        expect(result).toEqual({
-          type: 'div',
-          children: [
-            { type: 'text', attr: { value: 'Hello' }},
-            { type: 'text', attr: { value: 'World' }}
-          ]
-        })
-      }),
-      checkRefresh(instance, { counter: 2 }, result => {
-        expect(result).toEqual({
-          type: 'div',
-          children: [
-            { type: 'text', attr: { value: 'Hello' }},
-            { type: 'text', attr: { value: 'World' }},
-            { type: 'text', attr: { value: 'Weex' }}
-          ]
-        })
-      }),
-      checkRefresh(instance, { counter: 3 }, result => {
-        expect(result).toEqual({
-          type: 'div',
-          children: [
-            { type: 'text', attr: { value: 'Hello' }},
-            { type: 'text', attr: { value: 'Weex' }}
-          ]
-        })
-      }),
-      checkRefresh(instance, { counter: 4 }, result => {
-        expect(result).toEqual({
-          type: 'div',
-          children: [
-            { type: 'text', attr: { value: 'Weex' }}
-          ]
-        })
-      }),
-      checkRefresh(instance, { counter: 5 }, result => {
-        expect(result).toEqual({
-          type: 'div',
-          children: [
-            { type: 'text', attr: { value: 'Hello' }},
-            { type: 'text', attr: { value: 'Weex' }}
-          ]
-        })
-      }),
-      checkRefresh(instance, { counter: 6 }, result => {
-        expect(result).toEqual({
-          type: 'div',
-          children: [
-            { type: 'input', attr: { value: 'Hello' }},
-            { type: 'text', attr: { value: 'Weex' }}
-          ]
-        })
-        done()
-      })
-    ])
-  })
-
-  it('should be generated with component diff', (done) => {
-    const id = String(Date.now() * Math.random())
-    const instance = createInstance(id, `
-      new Vue({
-        data: {
-          counter: 0
-        },
-        components: {
-          foo: {
-            props: { a: { default: '1' }, b: { default: '2' }},
-            render: function (createElement) {
-              return createElement('text', { attrs: { value: this.a + '-' + this.b }}, [])
-            }
-          },
-          bar: {
-            render: function (createElement) {
-              return createElement('text', { attrs: { value: 'Bar' }, style: { fontSize: 100 }})
-            }
-          },
-          baz: {
-            render: function (createElement) {
-              return createElement('image', { attrs: { src: 'http://example.com/favicon.ico' }})
-            }
-          }
-        },
-        render: function (createElement) {
-          switch (this.counter) {
-            case 1:
-            return createElement('div', {}, [
-              createElement('foo', { props: { a: '111', b: '222' }}, [])
-            ])
-
-            case 2:
-            return createElement('div', {}, [
-              createElement('foo', {}, [])
-            ])
-
-            case 3:
-            return createElement('div', {}, [
-              createElement('bar', {}, [])
-            ])
-
-            case 4:
-            return createElement('div', {}, [
-              createElement('baz', {}, [])
-            ])
-
-            case 5:
-            return createElement('div', {}, [
-              createElement('foo', {}, []),
-              createElement('bar', {}, []),
-              createElement('baz', {}, [])
-            ])
-
-            default:
-            return createElement('div', {}, [
-              createElement('foo', { props: { a: '111' }}, [])
-            ])
-          }
-        },
-        el: "body"
-      })
-    `)
-    expect(getRoot(instance)).toEqual({
-      type: 'div',
-      children: [
-        { type: 'text', attr: { value: '111-2' }}
-      ]
-    })
-
-    syncPromise([
-      checkRefresh(instance, { counter: 1 }, result => {
-        expect(result).toEqual({
-          type: 'div',
-          children: [
-            { type: 'text', attr: { value: '111-222' }}
-          ]
-        })
-      }),
-      checkRefresh(instance, { counter: 2 }, result => {
-        expect(result).toEqual({
-          type: 'div',
-          children: [
-            { type: 'text', attr: { value: '1-2' }}
-          ]
-        })
-      }),
-      checkRefresh(instance, { counter: 3 }, result => {
-        expect(result).toEqual({
-          type: 'div',
-          children: [
-            { type: 'text', attr: { value: 'Bar' }, style: { fontSize: 100 }}
-          ]
-        })
-      }),
-      checkRefresh(instance, { counter: 4 }, result => {
-        expect(result).toEqual({
-          type: 'div',
-          children: [
-            { type: 'image', attr: { src: 'http://example.com/favicon.ico' }}
-          ]
-        })
-      }),
-      checkRefresh(instance, { counter: 5 }, result => {
-        expect(result).toEqual({
-          type: 'div',
-          children: [
-            { type: 'text', attr: { value: '1-2' }},
-            { type: 'text', attr: { value: 'Bar' }, style: { fontSize: 100 }},
-            { type: 'image', attr: { src: 'http://example.com/favicon.ico' }}
-          ]
-        })
-        done()
-      })
-    ])
-  })
-})
diff --git a/1.Vue/test/weex/runtime/style.spec.js b/1.Vue/test/weex/runtime/style.spec.js
deleted file mode 100644
index 752f575..0000000
--- a/1.Vue/test/weex/runtime/style.spec.js
+++ /dev/null
@@ -1,129 +0,0 @@
-import { getRoot, fireEvent, compileAndExecute } from '../helpers/index'
-
-describe('generate style', () => {
-  it('should be generated', () => {
-    compileAndExecute(`
-      <div>
-        <text style="font-size: 100">Hello World</text>
-      </div>
-    `).then(instance => {
-      expect(getRoot(instance)).toEqual({
-        type: 'div',
-        children: [{
-          type: 'text',
-          style: { fontSize: '100' },
-          attr: { value: 'Hello World' }
-        }]
-      })
-    })
-  })
-
-  it('should be generated by array binding', (done) => {
-    compileAndExecute(`
-      <div>
-        <text :style="[x, y]" @click="foo">Hello {{z}}</text>
-      </div>
-    `, `
-      data: {
-        x: { fontSize: 100, color: '#00ff00' },
-        y: { color: '#ff0000', fontWeight: 'bold' },
-        z: 'World'
-      },
-      methods: {
-        foo: function () {
-          this.x.fontSize = 200
-          this.x.color = '#0000ff'
-          Vue.delete(this.y, 'fontWeight')
-          this.z = 'Weex'
-        }
-      }
-    `).then(instance => {
-      expect(getRoot(instance)).toEqual({
-        type: 'div',
-        children: [
-          {
-            type: 'text',
-            event: ['click'],
-            style: { fontSize: 100, color: '#ff0000', fontWeight: 'bold' },
-            attr: { value: 'Hello World' }
-          }
-        ]
-      })
-      fireEvent(instance, instance.document.body.children[0].ref, 'click')
-      return instance
-    }).then(instance => {
-      expect(getRoot(instance)).toEqual({
-        type: 'div',
-        children: [
-          {
-            type: 'text',
-            event: ['click'],
-            style: { fontSize: 200, color: '#ff0000', fontWeight: '' },
-            attr: { value: 'Hello Weex' }
-          }
-        ]
-      })
-      done()
-    })
-  })
-
-  it('should be generated by map binding', (done) => {
-    compileAndExecute(`
-      <div>
-        <text :style="{ fontSize: x, color: '#00ff00' }" @click="foo">Hello</text>
-        <text :style="y">{{z}}</text>
-      </div>
-    `, `
-      data: {
-        x: 100,
-        y: { color: '#ff0000', fontWeight: 'bold' },
-        z: 'World'
-      },
-      methods: {
-        foo: function () {
-          this.x = 200
-          this.y.color = '#0000ff'
-          Vue.delete(this.y, 'fontWeight')
-          this.z = 'Weex'
-        }
-      }
-    `).then(instance => {
-      expect(getRoot(instance)).toEqual({
-        type: 'div',
-        children: [
-          {
-            type: 'text',
-            event: ['click'],
-            style: { fontSize: 100, color: '#00ff00' },
-            attr: { value: 'Hello' }
-          },
-          {
-            type: 'text',
-            style: { color: '#ff0000', fontWeight: 'bold' },
-            attr: { value: 'World' }
-          }
-        ]
-      })
-      fireEvent(instance, instance.document.body.children[0].ref, 'click')
-      return instance
-    }).then(instance => {
-      expect(getRoot(instance)).toEqual({
-        type: 'div',
-        children: [
-          {
-            type: 'text',
-            event: ['click'],
-            style: { fontSize: 200, color: '#00ff00' },
-            attr: { value: 'Hello' }
-          },
-          {
-            type: 'text',
-            style: { color: '#0000ff', fontWeight: '' },
-            attr: { value: 'Weex' }
-          }
-        ]
-      })
-      done()
-    })
-  })
-})