diff --git a/dist/fix/fix.js b/dist/fix/fix.js
index 54ae610ef..e16bdf99f 100644
--- a/dist/fix/fix.js
+++ b/dist/fix/fix.js
@@ -90,12 +90,13 @@ function _classCallCheck(instance, Constructor) { if (!(instance instanceof Cons
         }
     }
 
-    var bailRE = /[^\w.$]/;
+    // const bailRE = /[^\w.$]/
 
     function parsePath(path) {
-        if (bailRE.test(path)) {
-            return;
-        }
+        // 正常表达式比较慢，能不要的就不要了
+        // if (bailRE.test(path)) {
+        //     return
+        // }
         var segments = path.split('.');
         return function (obj) {
             for (var i = 0; i < segments.length; i++) {
@@ -975,7 +976,7 @@ function _classCallCheck(instance, Constructor) { if (!(instance instanceof Cons
         options = options || {};
         options.user = true;
         var exps = void 0;
-        if (_.isFunction(expOrFn) || !(exps = expOrFn.match(/[a-zA-Z0-9_.*]+|[|][|]|[&][&]|[(]|[)]/g)) || exps.length === 1 && !/\*/.test(expOrFn)) {
+        if (_.isFunction(expOrFn) || !(exps = expOrFn.match(/[a-zA-Z0-9_.*]+|[|][|]|[&][&]|[(]|[)]/g)) || exps.length === 1 && expOrFn.indexOf("*") < 0) {
             var watcher = new Watcher(model, expOrFn, cb, options);
             if (options.immediate) {
                 cb(watcher.value);
@@ -1016,45 +1017,96 @@ function _classCallCheck(instance, Constructor) { if (!(instance instanceof Cons
             if (_.has(operators, exp)) {
                 return;
             }
-            //a.**或a.*形式
-            if (/^[1-9a-zA-Z.]+(\*\*$|\*$)/.test(exp) || exp === "**") {
-                var isGlobal = /\*\*$/.test(exp);
-                if (isGlobal) {
-                    //a.**的形式
-                    exp = exp.replace(".**", "");
-                } else {
-                    //a.*的形式
-                    exp = exp.replace(".*", "");
+            if (exp.indexOf("*") >= 0) {
+                //a.**或a.*形式
+                if (/^[1-9a-zA-Z.]+(\*\*$|\*$)/.test(exp) || exp === "**" || exp === "*") {
+                    var isGlobal = exp.indexOf("**") >= 0;
+                    if (isGlobal) {
+                        //a.**的形式
+                        exp = exp.replace(".**", "");
+                    } else {
+                        //a.*的形式
+                        exp = exp.replace(".*", "");
+                    }
+                    var getter = exp === "**" || exp === "*" ? function (m) {
+                        return m;
+                    } : parsePath(exp);
+                    var v = getter.call(model, model);
+                    var _dep = new Dep();
+                    if (isGlobal) {
+                        (v.__ob__._scopeDeps || (v.__ob__._scopeDeps = [])).push(_dep);
+                    } else {
+                        (v.__ob__._deps || (v.__ob__._deps = [])).push(_dep);
+                    }
+                    var _w = new Watcher(model, function () {
+                        _dep.depend();
+                        return NaN;
+                    }, function (newValue, oldValue, attrs) {
+                        callback(i, newValue, oldValue, _.extend({ index: i }, attrs));
+                    }, options);
+                    watchers.push(function unwatchFn() {
+                        _w.teardown();
+                        v.__ob__._scopeDeps && remove(v.__ob__._scopeDeps, _dep);
+                        v.__ob__._deps && remove(v.__ob__._deps, _dep);
+                    });
+                    return;
                 }
-                var getter = exp === "**" ? function (m) {
-                    return m;
-                } : parsePath(exp);
-                var v = getter.call(model, model);
-                var dep = new Dep();
-                if (isGlobal) {
-                    (v.__ob__._scopeDeps || (v.__ob__._scopeDeps = [])).push(dep);
-                } else {
-                    (v.__ob__._deps || (v.__ob__._deps = [])).push(dep);
+                // **.a.**的情况，场景：a.b.c, 如果用b.**监听, a被重新赋值b上的_scopeDes就不存在了
+                if (/^(\*\*\.)+[1-9a-zA-Z]+(\.\*\*$)/.test(exp)) {
+                    //先获取到能获取到的对象
+                    var _paths = exp.split(".");
+                    var _currentModel = model[_paths[1]];
+                    exp = _paths[1] + ".**";
+                    //补全路径
+                    var _parent = _currentModel.__ob__.parent,
+                        _root = _currentModel.__ob__;
+                    while (_parent) {
+                        exp = '*.' + exp;
+                        _root = _parent;
+                        _parent = _parent.parent;
+                    }
+                    var _regStr = routeToRegExp(exp);
+                    var _dep2 = new Dep();
+                    _root._globalDeps || (_root._globalDeps = {});
+                    if (_.isArray(_root._globalDeps[_regStr])) {
+                        _root._globalDeps[_regStr].push(_dep2);
+                    } else {
+                        _root._globalDeps[_regStr] = [_dep2];
+                    }
+
+                    var _w2 = new Watcher(_currentModel, function () {
+                        _dep2.depend();
+                        return NaN;
+                    }, function (newValue, oldValue, attrs) {
+                        callback(i, newValue, oldValue, _.extend({ index: i }, attrs));
+                    }, options);
+                    watchers.push(function unwatchFn() {
+                        if (_root._globalDeps) {
+                            remove(_root._globalDeps[_regStr], _dep2);
+
+                            if (_root._globalDeps[_regStr].length === 0) {
+                                delete _root._globalDeps[_regStr];
+                                _w2.teardown();
+                            }
+                        }
+                    });
+                    return;
                 }
-                var w = new Watcher(model, function () {
-                    dep.depend();
-                    return NaN;
-                }, function (newValue, oldValue, attrs) {
-                    callback(i, newValue, oldValue, _.extend({ index: i }, attrs));
-                }, options);
-                watchers.push(function unwatchFn() {
-                    w.teardown();
-                    v.__ob__._scopeDeps && remove(v.__ob__._scopeDeps, dep);
-                    v.__ob__._deps && remove(v.__ob__._deps, dep);
-                });
-                return;
-            }
-            // **.a.**的情况，场景：a.b.c, 如果用b.**监听, a被重新赋值b上的_scopeDes就不存在了
-            if (/^(\*\*\.)+[1-9a-zA-Z]+(\.\*\*$)/.test(exp)) {
+                // 再有结尾有*的就不支持了
+                if (exp[exp.length - 1] === "*") {
+                    throw new Error('not support');
+                }
+                //其他含有*的情况，如*.a,*.*.a,a.*.a
+                var currentModel = model;
                 //先获取到能获取到的对象
                 var paths = exp.split(".");
-                var currentModel = model[paths[1]];
-                exp = paths[1] + ".**";
+                for (var _i = 0, len = paths.length; _i < len; _i++) {
+                    if (paths[_i] === "*") {
+                        break;
+                    }
+                    currentModel = model[paths[_i]];
+                }
+                exp = exp.substr(exp.indexOf("*"));
                 //补全路径
                 var parent = currentModel.__ob__.parent,
                     root = currentModel.__ob__;
@@ -1064,77 +1116,26 @@ function _classCallCheck(instance, Constructor) { if (!(instance instanceof Cons
                     parent = parent.parent;
                 }
                 var regStr = routeToRegExp(exp);
-                var _dep = new Dep();
+                var dep = new Dep();
                 root._globalDeps || (root._globalDeps = {});
                 if (_.isArray(root._globalDeps[regStr])) {
-                    root._globalDeps[regStr].push(_dep);
+                    root._globalDeps[regStr].push(dep);
                 } else {
-                    root._globalDeps[regStr] = [_dep];
+                    root._globalDeps[regStr] = [dep];
                 }
 
-                var _w = new Watcher(currentModel, function () {
-                    _dep.depend();
+                var w = new Watcher(currentModel, function () {
+                    dep.depend();
                     return NaN;
                 }, function (newValue, oldValue, attrs) {
                     callback(i, newValue, oldValue, _.extend({ index: i }, attrs));
                 }, options);
                 watchers.push(function unwatchFn() {
                     if (root._globalDeps) {
-                        remove(root._globalDeps[regStr], _dep);
-
+                        remove(root._globalDeps[regStr], dep);
                         if (root._globalDeps[regStr].length === 0) {
                             delete root._globalDeps[regStr];
-                            _w.teardown();
-                        }
-                    }
-                });
-                return;
-            }
-            if (/\*\*$|\*$/.test(exp)) {
-                throw new Error('not support');
-            }
-            //其他含有*的情况，如*.a,*.*.a,a.*.a
-            if (/\*/.test(exp)) {
-                var _currentModel = model;
-                //先获取到能获取到的对象
-                var _paths = exp.split(".");
-                for (var _i = 0, len = _paths.length; _i < len; _i++) {
-                    if (_paths[_i] === "*") {
-                        break;
-                    }
-                    _currentModel = model[_paths[_i]];
-                }
-                exp = exp.substr(exp.indexOf("*"));
-                //补全路径
-                var _parent = _currentModel.__ob__.parent,
-                    _root = _currentModel.__ob__;
-                while (_parent) {
-                    exp = '*.' + exp;
-                    _root = _parent;
-                    _parent = _parent.parent;
-                }
-                var _regStr = routeToRegExp(exp);
-                var _dep2 = new Dep();
-                _root._globalDeps || (_root._globalDeps = {});
-                if (_.isArray(_root._globalDeps[_regStr])) {
-                    _root._globalDeps[_regStr].push(_dep2);
-                } else {
-                    _root._globalDeps[_regStr] = [_dep2];
-                }
-
-                var _w2 = new Watcher(_currentModel, function () {
-                    _dep2.depend();
-                    return NaN;
-                }, function (newValue, oldValue, attrs) {
-                    callback(i, newValue, oldValue, _.extend({ index: i }, attrs));
-                }, options);
-                watchers.push(function unwatchFn() {
-                    if (_root._globalDeps) {
-                        remove(_root._globalDeps[_regStr], _dep2);
-
-                        if (_root._globalDeps[_regStr].length === 0) {
-                            delete _root._globalDeps[_regStr];
-                            _w2.teardown();
+                            w.teardown();
                         }
                     }
                 });
diff --git a/dist/fix/fix.proxy.js b/dist/fix/fix.proxy.js
index 513db8d93..d760047bd 100644
--- a/dist/fix/fix.proxy.js
+++ b/dist/fix/fix.proxy.js
@@ -1,2035 +1,2458 @@
 (function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
-        typeof define === 'function' && define.amd ? define(['exports'], factory) :
-            (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.Fix = {}));
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+  typeof define === 'function' && define.amd ? define(['exports'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.Fix = {}));
 }(this, (function (exports) { 'use strict';
 
-    function _typeof(obj) {
-        "@babel/helpers - typeof";
-
-        if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
-            _typeof = function (obj) {
-                return typeof obj;
+  function _typeof(obj) {
+    "@babel/helpers - typeof";
+
+    if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+      _typeof = function (obj) {
+        return typeof obj;
+      };
+    } else {
+      _typeof = function (obj) {
+        return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+      };
+    }
+
+    return _typeof(obj);
+  }
+
+  function _classCallCheck(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+      throw new TypeError("Cannot call a class as a function");
+    }
+  }
+
+  function _defineProperties(target, props) {
+    for (var i = 0; i < props.length; i++) {
+      var descriptor = props[i];
+      descriptor.enumerable = descriptor.enumerable || false;
+      descriptor.configurable = true;
+      if ("value" in descriptor) descriptor.writable = true;
+      Object.defineProperty(target, descriptor.key, descriptor);
+    }
+  }
+
+  function _createClass(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+  }
+
+  function _defineProperty(obj, key, value) {
+    if (key in obj) {
+      Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    } else {
+      obj[key] = value;
+    }
+
+    return obj;
+  }
+
+  function _slicedToArray(arr, i) {
+    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+  }
+
+  function _toConsumableArray(arr) {
+    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+  }
+
+  function _arrayWithoutHoles(arr) {
+    if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+  }
+
+  function _arrayWithHoles(arr) {
+    if (Array.isArray(arr)) return arr;
+  }
+
+  function _iterableToArray(iter) {
+    if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter);
+  }
+
+  function _iterableToArrayLimit(arr, i) {
+    if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _e = undefined;
+
+    try {
+      for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
+        _arr.push(_s.value);
+
+        if (i && _arr.length === i) break;
+      }
+    } catch (err) {
+      _d = true;
+      _e = err;
+    } finally {
+      try {
+        if (!_n && _i["return"] != null) _i["return"]();
+      } finally {
+        if (_d) throw _e;
+      }
+    }
+
+    return _arr;
+  }
+
+  function _unsupportedIterableToArray(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(o);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+  }
+
+  function _arrayLikeToArray(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+
+    for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+
+    return arr2;
+  }
+
+  function _nonIterableSpread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+
+  function _nonIterableRest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+
+  function _createForOfIteratorHelper(o, allowArrayLike) {
+    var it;
+
+    if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) {
+      if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
+        if (it) o = it;
+        var i = 0;
+
+        var F = function () {};
+
+        return {
+          s: F,
+          n: function () {
+            if (i >= o.length) return {
+              done: true
             };
-        } else {
-            _typeof = function (obj) {
-                return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+            return {
+              done: false,
+              value: o[i++]
             };
-        }
-
-        return _typeof(obj);
-    }
-
-    function _classCallCheck(instance, Constructor) {
-        if (!(instance instanceof Constructor)) {
-            throw new TypeError("Cannot call a class as a function");
-        }
-    }
-
-    function _defineProperties(target, props) {
-        for (var i = 0; i < props.length; i++) {
-            var descriptor = props[i];
-            descriptor.enumerable = descriptor.enumerable || false;
-            descriptor.configurable = true;
-            if ("value" in descriptor) descriptor.writable = true;
-            Object.defineProperty(target, descriptor.key, descriptor);
-        }
-    }
-
-    function _createClass(Constructor, protoProps, staticProps) {
-        if (protoProps) _defineProperties(Constructor.prototype, protoProps);
-        if (staticProps) _defineProperties(Constructor, staticProps);
-        return Constructor;
-    }
-
-    function _defineProperty(obj, key, value) {
-        if (key in obj) {
-            Object.defineProperty(obj, key, {
-                value: value,
-                enumerable: true,
-                configurable: true,
-                writable: true
-            });
-        } else {
-            obj[key] = value;
-        }
-
-        return obj;
-    }
-
-    var EMPTY_OBJ = Object.freeze({});
-    Object.freeze([]);
-    var extend = Object.assign;
-    var hasOwnProperty = Object.prototype.hasOwnProperty;
-
-    var hasOwn = function hasOwn(val, key) {
-        return hasOwnProperty.call(val, key);
+          },
+          e: function (e) {
+            throw e;
+          },
+          f: F
+        };
+      }
+
+      throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+    }
+
+    var normalCompletion = true,
+        didErr = false,
+        err;
+    return {
+      s: function () {
+        it = o[Symbol.iterator]();
+      },
+      n: function () {
+        var step = it.next();
+        normalCompletion = step.done;
+        return step;
+      },
+      e: function (e) {
+        didErr = true;
+        err = e;
+      },
+      f: function () {
+        try {
+          if (!normalCompletion && it.return != null) it.return();
+        } finally {
+          if (didErr) throw err;
+        }
+      }
     };
-
-    var isArray = Array.isArray;
-
-    var isMap$1 = function isMap(val) {
-        return toTypeString$1(val) === "[object Map]";
+  }
+
+  /**
+   * Make a map and return a function for checking if a key
+   * is in that map.
+   * IMPORTANT: all calls of this function must be prefixed with
+   * \/\*#\_\_PURE\_\_\*\/
+   * So that rollup can tree-shake them if necessary.
+   */
+  function makeMap(str, expectsLowerCase) {
+    var map = Object.create(null);
+    var list = str.split(',');
+
+    for (var i = 0; i < list.length; i++) {
+      map[list[i]] = true;
+    }
+
+    return expectsLowerCase ? function (val) {
+      return !!map[val.toLowerCase()];
+    } : function (val) {
+      return !!map[val];
     };
+  }
 
-    var isFunction = function isFunction(val) {
-        return typeof val === "function";
-    };
+  Object.freeze({});
+  Object.freeze([]);
+  var extend = Object.assign;
+  var hasOwnProperty = Object.prototype.hasOwnProperty;
 
-    var isString = function isString(val) {
-        return typeof val === "string";
-    };
+  var hasOwn = function hasOwn(val, key) {
+    return hasOwnProperty.call(val, key);
+  };
 
-    var isSymbol = function isSymbol(val) {
-        return _typeof(val) === "symbol";
-    };
+  var isArray = Array.isArray;
 
-    var isObject = function isObject(val) {
-        return val !== null && _typeof(val) === "object";
-    };
+  var isMap$1 = function isMap(val) {
+    return toTypeString$1(val) === '[object Map]';
+  };
 
-    var objectToString$1 = Object.prototype.toString;
+  var isFunction = function isFunction(val) {
+    return typeof val === 'function';
+  };
 
-    var toTypeString$1 = function toTypeString(value) {
-        return objectToString$1.call(value);
-    };
+  var isString = function isString(val) {
+    return typeof val === 'string';
+  };
 
-    var toRawType = function toRawType(value) {
-        return (// extract "RawType" from strings like "[object RawType]"
-            toTypeString$1(value).slice(8, -1)
-        );
-    };
+  var isSymbol = function isSymbol(val) {
+    return _typeof(val) === 'symbol';
+  };
 
-    var isIntegerKey = function isIntegerKey(key) {
-        return isString(key) && key !== "NaN" && key[0] !== "-" && "".concat(parseInt(key, 10)) === key;
-    };
+  var isObject = function isObject(val) {
+    return val !== null && _typeof(val) === 'object';
+  };
 
-    var cacheStringFunction = function cacheStringFunction(fn) {
-        var cache = Object.create(null);
-        return function (str) {
-            var hit = cache[str];
-            return hit || (cache[str] = fn(str));
-        };
-    };
-    /**
-     * @private
-     */
+  var objectToString$1 = Object.prototype.toString;
 
+  var toTypeString$1 = function toTypeString(value) {
+    return objectToString$1.call(value);
+  };
 
-    var capitalize = cacheStringFunction(function (str) {
-        return str.charAt(0).toUpperCase() + str.slice(1);
-    }); // compare whether a value has changed, accounting for NaN.
+  var toRawType = function toRawType(value) {
+    // extract "RawType" from strings like "[object RawType]"
+    return toTypeString$1(value).slice(8, -1);
+  };
 
-    var hasChanged$1 = function hasChanged(value, oldValue) {
-        return value !== oldValue && (value === value || oldValue === oldValue);
-    };
+  var isIntegerKey = function isIntegerKey(key) {
+    return isString(key) && key !== 'NaN' && key[0] !== '-' && '' + parseInt(key, 10) === key;
+  };
 
-    var targetMap = new WeakMap();
-    var effectStack = [];
-    var activeEffect;
-    var ITERATE_KEY = Symbol("iterate");
-    var MAP_KEY_ITERATE_KEY = Symbol("Map key iterate");
+  var cacheStringFunction = function cacheStringFunction(fn) {
+    var cache = Object.create(null);
+    return function (str) {
+      var hit = cache[str];
+      return hit || (cache[str] = fn(str));
+    };
+  };
+  /**
+   * @private
+   */
 
-    function isEffect(fn) {
-        return fn && fn._isEffect === true;
-    }
 
-    function effect(fn) {
-        var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : EMPTY_OBJ;
+  var capitalize = cacheStringFunction(function (str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+  }); // compare whether a value has changed, accounting for NaN.
 
-        if (isEffect(fn)) {
-            fn = fn.raw;
-        }
+  var hasChanged$1 = function hasChanged(value, oldValue) {
+    return !Object.is(value, oldValue);
+  };
 
-        var effect = createReactiveEffect(fn, options);
+  var activeEffectScope;
 
-        if (!options.lazy) {
-            effect();
-        }
+  function recordEffectScope(effect, scope) {
+    scope = scope || activeEffectScope;
 
-        return effect;
+    if (scope && scope.active) {
+      scope.effects.push(effect);
     }
+  }
 
-    function stop(effect) {
-        if (effect.active) {
-            cleanup(effect);
+  var createDep = function createDep(effects) {
+    var dep = new Set(effects);
+    dep.w = 0;
+    dep.n = 0;
+    return dep;
+  };
 
-            if (effect.options.onStop) {
-                effect.options.onStop();
-            }
+  var wasTracked = function wasTracked(dep) {
+    return (dep.w & trackOpBit) > 0;
+  };
 
-            effect.active = false;
-        }
-    }
-
-    var uid$1 = 0;
+  var newTracked = function newTracked(dep) {
+    return (dep.n & trackOpBit) > 0;
+  };
 
-    function createReactiveEffect(fn, options) {
-        var effect = function reactiveEffect() {
-            if (!effect.active) {
-                return options.scheduler ? undefined : fn();
-            }
-
-            if (!effectStack.includes(effect)) {
-                cleanup(effect);
-
-                try {
-                    enableTracking();
-                    effectStack.push(effect);
-                    activeEffect = effect;
-                    return fn();
-                } finally {
-                    effectStack.pop();
-                    resetTracking();
-                    activeEffect = effectStack[effectStack.length - 1];
-                }
-            }
-        };
+  var initDepMarkers = function initDepMarkers(_ref) {
+    var deps = _ref.deps;
 
-        effect.id = uid$1++;
-        effect.allowRecurse = !!options.allowRecurse;
-        effect._isEffect = true;
-        effect.active = true;
-        effect.raw = fn;
-        effect.deps = [];
-        effect.options = options;
-        return effect;
+    if (deps.length) {
+      for (var i = 0; i < deps.length; i++) {
+        deps[i].w |= trackOpBit; // set was tracked
+      }
     }
+  };
 
-    function cleanup(effect) {
-        var deps = effect.deps;
+  var finalizeDepMarkers = function finalizeDepMarkers(effect) {
+    var deps = effect.deps;
 
-        if (deps.length) {
-            for (var i = 0; i < deps.length; i++) {
-                deps[i].delete(effect);
-            }
+    if (deps.length) {
+      var ptr = 0;
 
-            deps.length = 0;
-        }
-    }
+      for (var i = 0; i < deps.length; i++) {
+        var dep = deps[i];
 
-    var shouldTrack = true;
-    var trackStack = [];
+        if (wasTracked(dep) && !newTracked(dep)) {
+          dep.delete(effect);
+        } else {
+          deps[ptr++] = dep;
+        } // clear bits
 
-    function pauseTracking() {
-        trackStack.push(shouldTrack);
-        shouldTrack = false;
-    }
 
-    function enableTracking() {
-        trackStack.push(shouldTrack);
-        shouldTrack = true;
-    }
+        dep.w &= ~trackOpBit;
+        dep.n &= ~trackOpBit;
+      }
 
-    function resetTracking() {
-        var last = trackStack.pop();
-        shouldTrack = last === undefined ? true : last;
+      deps.length = ptr;
     }
+  };
 
-    function track(target, type, key) {
-        if (!shouldTrack || activeEffect === undefined) {
-            return;
-        }
+  var targetMap = new WeakMap(); // The number of effects currently being tracked recursively.
 
-        var depsMap = targetMap.get(target);
+  var effectTrackDepth = 0;
+  var trackOpBit = 1;
+  /**
+   * The bitwise track markers support at most 30 levels of recursion.
+   * This value is chosen to enable modern JS engines to use a SMI on all platforms.
+   * When recursion depth is greater, fall back to using a full cleanup.
+   */
 
-        if (!depsMap) {
-            targetMap.set(target, depsMap = new Map());
-        }
+  var maxMarkerBits = 30;
+  var effectStack = [];
+  var activeEffect;
+  var ITERATE_KEY = Symbol('iterate');
+  var MAP_KEY_ITERATE_KEY = Symbol('Map key iterate');
 
-        var dep = depsMap.get(key);
+  var ReactiveEffect = /*#__PURE__*/function () {
+    function ReactiveEffect(fn) {
+      var scheduler = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+      var scope = arguments.length > 2 ? arguments[2] : undefined;
 
-        if (!dep) {
-            depsMap.set(key, dep = new Set());
-        }
+      _classCallCheck(this, ReactiveEffect);
 
-        if (!dep.has(activeEffect)) {
-            dep.add(activeEffect);
-            activeEffect.deps.push(dep);
-
-            if (activeEffect.options.onTrack) {
-                activeEffect.options.onTrack({
-                    effect: activeEffect,
-                    target: target,
-                    type: type,
-                    key: key
-                });
-            }
-        }
+      this.fn = fn;
+      this.scheduler = scheduler;
+      this.active = true;
+      this.deps = [];
+      recordEffectScope(this, scope);
     }
 
-    function trigger(target, type, key, newValue, oldValue, oldTarget) {
-        var depsMap = targetMap.get(target);
-
-        if (!depsMap) {
-            // never been tracked
-            return;
-        }
-
-        var effects = new Set();
-
-        var add = function add(effectsToAdd) {
-            if (effectsToAdd) {
-                effectsToAdd.forEach(function (effect) {
-                    if (effect !== activeEffect || effect.allowRecurse) {
-                        effects.add(effect);
-                    }
-                });
-            }
-        };
-
-        if (type === "clear"
-            /* CLEAR */
-        ) {
-            // collection being cleared
-            // trigger all effects for target
-            depsMap.forEach(add);
-        } else if (key === "length" && isArray(target)) {
-            depsMap.forEach(function (dep, key) {
-                if (key === "length" || key >= newValue) {
-                    add(dep);
-                }
-            });
-        } else {
-            // schedule runs for SET | ADD | DELETE
-            if (key !== void 0) {
-                add(depsMap.get(key));
-            } // also run for iteration key on ADD | DELETE | Map.SET
-
-
-            switch (type) {
-                case "add"
-                    /* ADD */
-                :
-                    if (!isArray(target)) {
-                        add(depsMap.get(ITERATE_KEY));
-
-                        if (isMap$1(target)) {
-                            add(depsMap.get(MAP_KEY_ITERATE_KEY));
-                        }
-                    } else if (isIntegerKey(key)) {
-                        // new index added to array -> length changes
-                        add(depsMap.get("length"));
-                    }
-
-                    break;
-
-                case "delete"
-                    /* DELETE */
-                :
-                    if (!isArray(target)) {
-                        add(depsMap.get(ITERATE_KEY));
-
-                        if (isMap$1(target)) {
-                            add(depsMap.get(MAP_KEY_ITERATE_KEY));
-                        }
-                    }
-
-                    break;
-
-                case "set"
-                    /* SET */
-                :
-                    if (isMap$1(target)) {
-                        add(depsMap.get(ITERATE_KEY));
-                    }
-
-                    break;
-            }
+    _createClass(ReactiveEffect, [{
+      key: "run",
+      value: function run() {
+        if (!this.active) {
+          return this.fn();
         }
 
-        var run = function run(effect) {
-            if (effect.options.onTrigger) {
-                effect.options.onTrigger({
-                    effect: effect,
-                    target: target,
-                    key: key,
-                    type: type,
-                    newValue: newValue,
-                    oldValue: oldValue,
-                    oldTarget: oldTarget
-                });
-            }
+        if (!effectStack.includes(this)) {
+          try {
+            effectStack.push(activeEffect = this);
+            enableTracking();
+            trackOpBit = 1 << ++effectTrackDepth;
 
-            if (effect.options.scheduler) {
-                effect.options.scheduler(effect);
+            if (effectTrackDepth <= maxMarkerBits) {
+              initDepMarkers(this);
             } else {
-                effect();
+              cleanupEffect(this);
             }
-        };
-
-        effects.forEach(run);
-    }
-
-    var builtInSymbols = new Set(Object.getOwnPropertyNames(Symbol).map(function (key) {
-        return Symbol[key];
-    }).filter(isSymbol));
-    var get = /* #__PURE__*/createGetter();
-    var shallowGet = /* #__PURE__*/createGetter(false, true);
-    var readonlyGet = /* #__PURE__*/createGetter(true);
-    var shallowReadonlyGet = /* #__PURE__*/createGetter(true, true);
-    var arrayInstrumentations = {};
-    ["includes", "indexOf", "lastIndexOf"].forEach(function (key) {
-        var method = Array.prototype[key];
-
-        arrayInstrumentations[key] = function () {
-            var arr = toRaw(this);
-
-            for (var i = 0, l = this.length; i < l; i++) {
-                track(arr, "get"
-                    /* GET */
-                    , "".concat(i));
-            } // we run the method using the original args first (which may be reactive)
-
 
-            for (var _len = arguments.length, args = new Array(_len), _key2 = 0; _key2 < _len; _key2++) {
-                args[_key2] = arguments[_key2];
+            return this.fn();
+          } finally {
+            if (effectTrackDepth <= maxMarkerBits) {
+              finalizeDepMarkers(this);
             }
 
-            var res = method.apply(arr, args);
-
-            if (res === -1 || res === false) {
-                // if that didn't work, run it again using raw values.
-                return method.apply(arr, args.map(toRaw));
-            } else {
-                return res;
-            }
-        };
-    });
-    ["push", "pop", "shift", "unshift", "splice"].forEach(function (key) {
-        var method = Array.prototype[key];
-
-        arrayInstrumentations[key] = function () {
-            pauseTracking();
-
-            for (var _len2 = arguments.length, args = new Array(_len2), _key3 = 0; _key3 < _len2; _key3++) {
-                args[_key3] = arguments[_key3];
-            }
-
-            var res = method.apply(this, args);
+            trackOpBit = 1 << --effectTrackDepth;
             resetTracking();
-            return res;
-        };
-    });
-
-    function createGetter() {
-        var isReadonly = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
-        var shallow = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-        return function get(target, key, receiver) {
-            if (key === "__v_isReactive"
-                /* IS_REACTIVE */
-            ) {
-                return !isReadonly;
-            } else if (key === "__v_isReadonly"
-                /* IS_READONLY */
-            ) {
-                return isReadonly;
-            } else if (key === "__v_raw"
-                /* RAW */
-                && receiver === (isReadonly ? readonlyMap : reactiveMap).get(target)) {
-                return target;
-            }
+            effectStack.pop();
+            var n = effectStack.length;
+            activeEffect = n > 0 ? effectStack[n - 1] : undefined;
+          }
+        }
+      }
+    }, {
+      key: "stop",
+      value: function stop() {
+        if (this.active) {
+          cleanupEffect(this);
 
-            var targetIsArray = isArray(target);
+          if (this.onStop) {
+            this.onStop();
+          }
 
-            if (targetIsArray && hasOwn(arrayInstrumentations, key)) {
-                return Reflect.get(arrayInstrumentations, key, receiver);
-            }
+          this.active = false;
+        }
+      }
+    }]);
 
-            var res = Reflect.get(target, key, receiver);
+    return ReactiveEffect;
+  }();
 
-            if (isSymbol(key) ? builtInSymbols.has(key) : key === "__proto__" || key === "__v_isRef") {
-                return res;
-            }
+  function cleanupEffect(effect) {
+    var deps = effect.deps;
 
-            if (!isReadonly) {
-                track(target, "get"
-                    /* GET */
-                    , key);
-            }
+    if (deps.length) {
+      for (var i = 0; i < deps.length; i++) {
+        deps[i].delete(effect);
+      }
 
-            if (shallow) {
-                return res;
-            }
+      deps.length = 0;
+    }
+  }
 
-            if (isRef(res)) {
-                // ref unwrapping - does not apply for Array + integer key.
-                var shouldUnwrap = !targetIsArray || !isIntegerKey(key);
-                return shouldUnwrap ? res.value : res;
-            }
+  function effect(fn, options) {
+    if (fn.effect) {
+      fn = fn.effect.fn;
+    }
 
-            if (isObject(res)) {
-                // Convert returned value into a proxy as well. we do the isObject check
-                // here to avoid invalid value warning. Also need to lazy access readonly
-                // and reactive here to avoid circular dependency.
-                return isReadonly ? readonly(res) : reactive(res);
-            }
+    var _effect = new ReactiveEffect(fn);
 
-            return res;
-        };
+    if (options) {
+      extend(_effect, options);
+      if (options.scope) recordEffectScope(_effect, options.scope);
     }
 
-    var set$1 = /* #__PURE__*/createSetter();
-    var shallowSet = /* #__PURE__*/createSetter(true);
+    if (!options || !options.lazy) {
+      _effect.run();
+    }
 
-    function createSetter() {
-        var shallow = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
-        return function set(target, key, value, receiver) {
-            var oldValue = target[key];
+    var runner = _effect.run.bind(_effect);
 
-            if (!shallow) {
-                value = toRaw(value);
+    runner.effect = _effect;
+    return runner;
+  }
 
-                if (!isArray(target) && isRef(oldValue) && !isRef(value)) {
-                    oldValue.value = value;
-                    return true;
-                }
-            }
+  function stop(runner) {
+    runner.effect.stop();
+  }
 
-            var hadKey = isArray(target) && isIntegerKey(key) ? Number(key) < target.length : hasOwn(target, key);
-            var result = Reflect.set(target, key, value, receiver); // don't trigger if target is something up in the prototype chain of original
-
-            if (target === toRaw(receiver)) {
-                if (!hadKey) {
-                    trigger(target, "add"
-                        /* ADD */
-                        , key, value);
-                } else if (hasChanged$1(value, oldValue) || key === "length") {
-                    trigger(target, "set"
-                        /* SET */
-                        , key, value, oldValue);
-                }
-            }
+  var shouldTrack = true;
+  var trackStack = [];
 
-            return result;
-        };
-    }
+  function pauseTracking() {
+    trackStack.push(shouldTrack);
+    shouldTrack = false;
+  }
 
-    function deleteProperty(target, key) {
-        var hadKey = hasOwn(target, key);
-        var oldValue = target[key];
-        var result = Reflect.deleteProperty(target, key);
+  function enableTracking() {
+    trackStack.push(shouldTrack);
+    shouldTrack = true;
+  }
 
-        if (result && hadKey) {
-            trigger(target, "delete"
-                /* DELETE */
-                , key, undefined, oldValue);
-        }
+  function resetTracking() {
+    var last = trackStack.pop();
+    shouldTrack = last === undefined ? true : last;
+  }
 
-        return result;
+  function track(target, type, key) {
+    if (!isTracking()) {
+      return;
     }
 
-    function has$1(target, key) {
-        var result = Reflect.has(target, key);
-
-        if (!isSymbol(key) || !builtInSymbols.has(key)) {
-            track(target, "has"
-                /* HAS */
-                , key);
-        }
+    var depsMap = targetMap.get(target);
 
-        return result;
+    if (!depsMap) {
+      targetMap.set(target, depsMap = new Map());
     }
 
-    function ownKeys(target) {
-        track(target, "iterate"
-            /* ITERATE */
-            , isArray(target) ? "length" : ITERATE_KEY);
-        return Reflect.ownKeys(target);
-    }
-
-    var mutableHandlers = {
-        get: get,
-        set: set$1,
-        deleteProperty: deleteProperty,
-        has: has$1,
-        ownKeys: ownKeys
-    };
-    var readonlyHandlers = {
-        get: readonlyGet,
-        set: function set(target, key) {
-            {
-                console.warn("Set operation on key \"".concat(String(key), "\" failed: target is readonly."), target);
-            }
-            return true;
-        },
-        deleteProperty: function deleteProperty(target, key) {
-            {
-                console.warn("Delete operation on key \"".concat(String(key), "\" failed: target is readonly."), target);
-            }
-            return true;
-        }
-    };
-    extend({}, mutableHandlers, {
-        get: shallowGet,
-        set: shallowSet
-    }); // Props handlers are special in the sense that it should not unwrap top-level
-    // refs (in order to allow refs to be explicitly passed down), but should
-    // retain the reactivity of the normal readonly object.
-
-    extend({}, readonlyHandlers, {
-        get: shallowReadonlyGet
-    });
-
-    var toReactive = function toReactive(value) {
-        return isObject(value) ? reactive(value) : value;
-    };
+    var dep = depsMap.get(key);
 
-    var toReadonly = function toReadonly(value) {
-        return isObject(value) ? readonly(value) : value;
-    };
-
-    var toShallow = function toShallow(value) {
-        return value;
-    };
+    if (!dep) {
+      depsMap.set(key, dep = createDep());
+    }
 
-    var getProto = function getProto(v) {
-        return Reflect.getPrototypeOf(v);
+    var eventInfo = {
+      effect: activeEffect,
+      target: target,
+      type: type,
+      key: key
     };
+    trackEffects(dep, eventInfo);
+  }
 
-    function get$1(target, key) {
-        var isReadonly = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-        var isShallow = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
-        // #1772: readonly(reactive(Map)) should return readonly + reactive version
-        // of the value
-        target = target["__v_raw"
-            /* RAW */
-            ];
-        var rawTarget = toRaw(target);
-        var rawKey = toRaw(key);
-
-        if (key !== rawKey) {
-            !isReadonly && track(rawTarget, "get"
-                /* GET */
-                , key);
-        }
-
-        !isReadonly && track(rawTarget, "get"
-            /* GET */
-            , rawKey);
+  function isTracking() {
+    return shouldTrack && activeEffect !== undefined;
+  }
 
-        var _getProto = getProto(rawTarget),
-            has = _getProto.has;
+  function trackEffects(dep, debuggerEventExtraInfo) {
+    var shouldTrack = false;
 
-        var wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;
+    if (effectTrackDepth <= maxMarkerBits) {
+      if (!newTracked(dep)) {
+        dep.n |= trackOpBit; // set newly tracked
 
-        if (has.call(rawTarget, key)) {
-            return wrap(target.get(key));
-        } else if (has.call(rawTarget, rawKey)) {
-            return wrap(target.get(rawKey));
-        }
+        shouldTrack = !wasTracked(dep);
+      }
+    } else {
+      // Full cleanup mode.
+      shouldTrack = !dep.has(activeEffect);
     }
 
-    function has$1$1(key) {
-        var isReadonly = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-        var target = this["__v_raw"
-            /* RAW */
-            ];
-        var rawTarget = toRaw(target);
-        var rawKey = toRaw(key);
-
-        if (key !== rawKey) {
-            !isReadonly && track(rawTarget, "has"
-                /* HAS */
-                , key);
-        }
+    if (shouldTrack) {
+      dep.add(activeEffect);
+      activeEffect.deps.push(dep);
 
-        !isReadonly && track(rawTarget, "has"
-            /* HAS */
-            , rawKey);
-        return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey);
+      if (activeEffect.onTrack) {
+        activeEffect.onTrack(Object.assign({
+          effect: activeEffect
+        }, debuggerEventExtraInfo));
+      }
     }
+  }
+
+  function trigger(target, type, key, newValue, oldValue, oldTarget) {
+    var depsMap = targetMap.get(target);
 
-    function size(target) {
-        var isReadonly = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-        target = target["__v_raw"
-            /* RAW */
-            ];
-        !isReadonly && track(toRaw(target), "iterate"
-            /* ITERATE */
-            , ITERATE_KEY);
-        return Reflect.get(target, "size", target);
+    if (!depsMap) {
+      // never been tracked
+      return;
     }
 
-    function add(value) {
-        value = toRaw(value);
-        var target = toRaw(this);
-        var proto = getProto(target);
-        var hadKey = proto.has.call(target, value);
-        var result = target.add(value);
+    var deps = [];
 
-        if (!hadKey) {
-            trigger(target, "add"
-                /* ADD */
-                , value, value);
+    if (type === "clear"
+    /* CLEAR */
+    ) {
+        // collection being cleared
+        // trigger all effects for target
+        deps = _toConsumableArray(depsMap.values());
+      } else if (key === 'length' && isArray(target)) {
+      depsMap.forEach(function (dep, key) {
+        if (key === 'length' || key >= newValue) {
+          deps.push(dep);
         }
+      });
+    } else {
+      // schedule runs for SET | ADD | DELETE
+      if (key !== void 0) {
+        deps.push(depsMap.get(key));
+      } // also run for iteration key on ADD | DELETE | Map.SET
 
-        return result;
-    }
 
-    function set$1$1(key, value) {
-        value = toRaw(value);
-        var target = toRaw(this);
-
-        var _getProto2 = getProto(target),
-            has = _getProto2.has,
-            get = _getProto2.get;
+      switch (type) {
+        case "add"
+        /* ADD */
+        :
+          if (!isArray(target)) {
+            deps.push(depsMap.get(ITERATE_KEY));
 
-        var hadKey = has.call(target, key);
+            if (isMap$1(target)) {
+              deps.push(depsMap.get(MAP_KEY_ITERATE_KEY));
+            }
+          } else if (isIntegerKey(key)) {
+            // new index added to array -> length changes
+            deps.push(depsMap.get('length'));
+          }
 
-        if (!hadKey) {
-            key = toRaw(key);
-            hadKey = has.call(target, key);
-        } else {
-            checkIdentityKeys(target, has, key);
-        }
+          break;
 
-        var oldValue = get.call(target, key);
-        var result = target.set(key, value);
+        case "delete"
+        /* DELETE */
+        :
+          if (!isArray(target)) {
+            deps.push(depsMap.get(ITERATE_KEY));
 
-        if (!hadKey) {
-            trigger(target, "add"
-                /* ADD */
-                , key, value);
-        } else if (hasChanged$1(value, oldValue) || key === "length") {
-            trigger(target, "set"
-                /* SET */
-                , key, value, oldValue);
-        }
+            if (isMap$1(target)) {
+              deps.push(depsMap.get(MAP_KEY_ITERATE_KEY));
+            }
+          }
 
-        return result;
-    }
+          break;
 
-    function deleteEntry(key) {
-        var target = toRaw(this);
+        case "set"
+        /* SET */
+        :
+          if (isMap$1(target)) {
+            deps.push(depsMap.get(ITERATE_KEY));
+          }
 
-        var _getProto3 = getProto(target),
-            has = _getProto3.has,
-            get = _getProto3.get;
+          break;
+      }
+    }
 
-        var hadKey = has.call(target, key);
+    var eventInfo = {
+      target: target,
+      type: type,
+      key: key,
+      newValue: newValue,
+      oldValue: oldValue,
+      oldTarget: oldTarget
+    };
 
-        if (!hadKey) {
-            key = toRaw(key);
-            hadKey = has.call(target, key);
+    if (deps.length === 1) {
+      if (deps[0]) {
+        {
+          triggerEffects(deps[0], eventInfo);
+        }
+      }
+    } else {
+      var effects = [];
+
+      var _iterator = _createForOfIteratorHelper(deps),
+          _step;
+
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var dep = _step.value;
+
+          if (dep) {
+            effects.push.apply(effects, _toConsumableArray(dep));
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+
+      {
+        triggerEffects(createDep(effects), eventInfo);
+      }
+    }
+  }
+
+  function triggerEffects(dep, debuggerEventExtraInfo) {
+    // spread into array for stabilization
+    var _iterator2 = _createForOfIteratorHelper(isArray(dep) ? dep : _toConsumableArray(dep)),
+        _step2;
+
+    try {
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        var _effect2 = _step2.value;
+
+        if (_effect2 !== activeEffect || _effect2.allowRecurse) {
+          if (_effect2.onTrigger) {
+            _effect2.onTrigger(extend({
+              effect: _effect2
+            }, debuggerEventExtraInfo));
+          }
+
+          if (_effect2.scheduler) {
+            _effect2.scheduler();
+          } else {
+            _effect2.run();
+          }
+        }
+      }
+    } catch (err) {
+      _iterator2.e(err);
+    } finally {
+      _iterator2.f();
+    }
+  }
+
+  var isNonTrackableKeys = /*#__PURE__*/makeMap("__proto__,__v_isRef,__isVue");
+  var builtInSymbols = new Set(Object.getOwnPropertyNames(Symbol).map(function (key) {
+    return Symbol[key];
+  }).filter(isSymbol));
+  var get = /*#__PURE__*/createGetter();
+  var readonlyGet = /*#__PURE__*/createGetter(true);
+  var arrayInstrumentations = /*#__PURE__*/createArrayInstrumentations();
+
+  function createArrayInstrumentations() {
+    var instrumentations = {};
+    ['includes', 'indexOf', 'lastIndexOf'].forEach(function (key) {
+      instrumentations[key] = function () {
+        var arr = toRaw(this);
+
+        for (var i = 0, l = this.length; i < l; i++) {
+          track(arr, "get"
+          /* GET */
+          , i + '');
+        } // we run the method using the original args first (which may be reactive)
+
+
+        for (var _len2 = arguments.length, args = new Array(_len2), _key3 = 0; _key3 < _len2; _key3++) {
+          args[_key3] = arguments[_key3];
+        }
+
+        var res = arr[key].apply(arr, args);
+
+        if (res === -1 || res === false) {
+          // if that didn't work, run it again using raw values.
+          return arr[key].apply(arr, _toConsumableArray(args.map(toRaw)));
         } else {
-            checkIdentityKeys(target, has, key);
+          return res;
         }
+      };
+    });
+    ['push', 'pop', 'shift', 'unshift', 'splice'].forEach(function (key) {
+      instrumentations[key] = function () {
+        pauseTracking();
 
-        var oldValue = get ? get.call(target, key) : undefined; // forward the operation before queueing reactions
-
-        var result = target.delete(key);
-
-        if (hadKey) {
-            trigger(target, "delete"
-                /* DELETE */
-                , key, undefined, oldValue);
+        for (var _len3 = arguments.length, args = new Array(_len3), _key4 = 0; _key4 < _len3; _key4++) {
+          args[_key4] = arguments[_key4];
         }
 
-        return result;
-    }
+        var res = toRaw(this)[key].apply(this, args);
+        resetTracking();
+        return res;
+      };
+    });
+    return instrumentations;
+  }
+
+  function createGetter() {
+    var isReadonly = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+    var shallow = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    return function get(target, key, receiver) {
+      if (key === "__v_isReactive"
+      /* IS_REACTIVE */
+      ) {
+          return !isReadonly;
+        } else if (key === "__v_isReadonly"
+      /* IS_READONLY */
+      ) {
+          return isReadonly;
+        } else if (key === "__v_raw"
+      /* RAW */
+      && receiver === (isReadonly ? shallow ? shallowReadonlyMap : readonlyMap : shallow ? shallowReactiveMap : reactiveMap).get(target)) {
+        return target;
+      }
+
+      var targetIsArray = isArray(target);
+
+      if (!isReadonly && targetIsArray && hasOwn(arrayInstrumentations, key)) {
+        return Reflect.get(arrayInstrumentations, key, receiver);
+      }
+
+      var res = Reflect.get(target, key, receiver);
+
+      if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) {
+        return res;
+      }
+
+      if (!isReadonly) {
+        track(target, "get"
+        /* GET */
+        , key);
+      }
+
+      if (shallow) {
+        return res;
+      }
+
+      if (isRef(res)) {
+        // ref unwrapping - does not apply for Array + integer key.
+        var shouldUnwrap = !targetIsArray || !isIntegerKey(key);
+        return shouldUnwrap ? res.value : res;
+      }
+
+      if (isObject(res)) {
+        // Convert returned value into a proxy as well. we do the isObject check
+        // here to avoid invalid value warning. Also need to lazy access readonly
+        // and reactive here to avoid circular dependency.
+        return isReadonly ? readonly(res) : reactive(res);
+      }
+
+      return res;
+    };
+  }
+
+  var set$1 = /*#__PURE__*/createSetter();
 
-    function clear() {
-        var target = toRaw(this);
-        var hadItems = target.size !== 0;
-        var oldTarget = isMap$1(target) ? new Map(target) : new Set(target); // forward the operation before queueing reactions
+  function createSetter() {
+    var shallow = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+    return function set(target, key, value, receiver) {
+      var oldValue = target[key];
 
-        var result = target.clear();
+      if (!shallow && !isReadonly(value)) {
+        value = toRaw(value);
+        oldValue = toRaw(oldValue);
 
-        if (hadItems) {
-            trigger(target, "clear"
-                /* CLEAR */
-                , undefined, undefined, oldTarget);
+        if (!isArray(target) && isRef(oldValue) && !isRef(value)) {
+          oldValue.value = value;
+          return true;
         }
+      }
 
-        return result;
-    }
-
-    function createForEach(isReadonly, isShallow) {
-        return function forEach(callback, thisArg) {
-            var observed = this;
-            var target = observed["__v_raw"
-                /* RAW */
-                ];
-            var rawTarget = toRaw(target);
-            var wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;
-            !isReadonly && track(rawTarget, "iterate"
-                /* ITERATE */
-                , ITERATE_KEY);
-            return target.forEach(function (value, key) {
-                return (// important: make sure the callback is
-                    // 1. invoked with the reactive map as `this` and 3rd arg
-                    // 2. the value received should be a corresponding reactive/readonly.
-                    callback.call(thisArg, wrap(value), wrap(key), observed)
-                );
-            });
-        };
-    }
+      var hadKey = isArray(target) && isIntegerKey(key) ? Number(key) < target.length : hasOwn(target, key);
+      var result = Reflect.set(target, key, value, receiver); // don't trigger if target is something up in the prototype chain of original
 
-    function createIterableMethod(method, isReadonly, isShallow) {
-        return function () {
-            var target = this["__v_raw"
-                /* RAW */
-                ];
-            var rawTarget = toRaw(target);
-            var targetIsMap = isMap$1(rawTarget);
-            var isPair = method === "entries" || method === Symbol.iterator && targetIsMap;
-            var isKeyOnly = method === "keys" && targetIsMap;
-            var innerIterator = target[method].apply(target, arguments);
-            var wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;
-            !isReadonly && track(rawTarget, "iterate"
-                /* ITERATE */
-                , isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY); // return a wrapped iterator which returns observed versions of the
-            // values emitted from the real iterator
-
-            return _defineProperty({
-                // iterator protocol
-                next: function next() {
-                    var _innerIterator$next = innerIterator.next(),
-                        value = _innerIterator$next.value,
-                        done = _innerIterator$next.done;
-
-                    return done ? {
-                        value: value,
-                        done: done
-                    } : {
-                        value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),
-                        done: done
-                    };
-                }
-            }, Symbol.iterator, function () {
-                return this;
-            });
-        };
-    }
-
-    function createReadonlyMethod(type) {
-        return function () {
-            {
-                var key = (arguments.length <= 0 ? undefined : arguments[0]) ? "on key \"".concat(arguments.length <= 0 ? undefined : arguments[0], "\" ") : "";
-                console.warn("".concat(capitalize(type), " operation ").concat(key, "failed: target is readonly."), toRaw(this));
-            }
-            return type === "delete"
-                /* DELETE */
-                ? false : this;
-        };
-    }
+      if (target === toRaw(receiver)) {
+        if (!hadKey) {
+          trigger(target, "add"
+          /* ADD */
+          , key, value);
+        } else if (hasChanged$1(value, oldValue)) {
+          trigger(target, "set"
+          /* SET */
+          , key, value, oldValue);
+        }
+      }
 
-    var mutableInstrumentations = {
-        get: function get(key) {
-            return get$1(this, key);
-        },
+      return result;
+    };
+  }
+
+  function deleteProperty(target, key) {
+    var hadKey = hasOwn(target, key);
+    var oldValue = target[key];
+    var result = Reflect.deleteProperty(target, key);
+
+    if (result && hadKey) {
+      trigger(target, "delete"
+      /* DELETE */
+      , key, undefined, oldValue);
+    }
+
+    return result;
+  }
+
+  function has$1(target, key) {
+    var result = Reflect.has(target, key);
+
+    if (!isSymbol(key) || !builtInSymbols.has(key)) {
+      track(target, "has"
+      /* HAS */
+      , key);
+    }
+
+    return result;
+  }
+
+  function ownKeys(target) {
+    track(target, "iterate"
+    /* ITERATE */
+    , isArray(target) ? 'length' : ITERATE_KEY);
+    return Reflect.ownKeys(target);
+  }
+
+  var mutableHandlers = {
+    get: get,
+    set: set$1,
+    deleteProperty: deleteProperty,
+    has: has$1,
+    ownKeys: ownKeys
+  };
+  var readonlyHandlers = {
+    get: readonlyGet,
+    set: function set(target, key) {
+      {
+        console.warn("Set operation on key \"".concat(String(key), "\" failed: target is readonly."), target);
+      }
+      return true;
+    },
+    deleteProperty: function deleteProperty(target, key) {
+      {
+        console.warn("Delete operation on key \"".concat(String(key), "\" failed: target is readonly."), target);
+      }
+      return true;
+    }
+  };
+
+  var toShallow = function toShallow(value) {
+    return value;
+  };
+
+  var getProto = function getProto(v) {
+    return Reflect.getPrototypeOf(v);
+  };
+
+  function get$1(target, key) {
+    var isReadonly = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    var isShallow = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+    // #1772: readonly(reactive(Map)) should return readonly + reactive version
+    // of the value
+    target = target["__v_raw"
+    /* RAW */
+    ];
+    var rawTarget = toRaw(target);
+    var rawKey = toRaw(key);
+
+    if (key !== rawKey) {
+      !isReadonly && track(rawTarget, "get"
+      /* GET */
+      , key);
+    }
+
+    !isReadonly && track(rawTarget, "get"
+    /* GET */
+    , rawKey);
+
+    var _getProto = getProto(rawTarget),
+        has = _getProto.has;
+
+    var wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
+
+    if (has.call(rawTarget, key)) {
+      return wrap(target.get(key));
+    } else if (has.call(rawTarget, rawKey)) {
+      return wrap(target.get(rawKey));
+    } else if (target !== rawTarget) {
+      // #3602 readonly(reactive(Map))
+      // ensure that the nested reactive `Map` can do tracking for itself
+      target.get(key);
+    }
+  }
+
+  function has$1$1(key) {
+    var isReadonly = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    var target = this["__v_raw"
+    /* RAW */
+    ];
+    var rawTarget = toRaw(target);
+    var rawKey = toRaw(key);
+
+    if (key !== rawKey) {
+      !isReadonly && track(rawTarget, "has"
+      /* HAS */
+      , key);
+    }
+
+    !isReadonly && track(rawTarget, "has"
+    /* HAS */
+    , rawKey);
+    return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey);
+  }
+
+  function size(target) {
+    var isReadonly = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    target = target["__v_raw"
+    /* RAW */
+    ];
+    !isReadonly && track(toRaw(target), "iterate"
+    /* ITERATE */
+    , ITERATE_KEY);
+    return Reflect.get(target, 'size', target);
+  }
+
+  function add(value) {
+    value = toRaw(value);
+    var target = toRaw(this);
+    var proto = getProto(target);
+    var hadKey = proto.has.call(target, value);
+
+    if (!hadKey) {
+      target.add(value);
+      trigger(target, "add"
+      /* ADD */
+      , value, value);
+    }
+
+    return this;
+  }
+
+  function set$1$1(key, value) {
+    value = toRaw(value);
+    var target = toRaw(this);
+
+    var _getProto2 = getProto(target),
+        has = _getProto2.has,
+        get = _getProto2.get;
+
+    var hadKey = has.call(target, key);
+
+    if (!hadKey) {
+      key = toRaw(key);
+      hadKey = has.call(target, key);
+    } else {
+      checkIdentityKeys(target, has, key);
+    }
+
+    var oldValue = get.call(target, key);
+    target.set(key, value);
+
+    if (!hadKey) {
+      trigger(target, "add"
+      /* ADD */
+      , key, value);
+    } else if (hasChanged$1(value, oldValue)) {
+      trigger(target, "set"
+      /* SET */
+      , key, value, oldValue);
+    }
+
+    return this;
+  }
+
+  function deleteEntry(key) {
+    var target = toRaw(this);
+
+    var _getProto3 = getProto(target),
+        has = _getProto3.has,
+        get = _getProto3.get;
+
+    var hadKey = has.call(target, key);
+
+    if (!hadKey) {
+      key = toRaw(key);
+      hadKey = has.call(target, key);
+    } else {
+      checkIdentityKeys(target, has, key);
+    }
+
+    var oldValue = get ? get.call(target, key) : undefined; // forward the operation before queueing reactions
+
+    var result = target.delete(key);
+
+    if (hadKey) {
+      trigger(target, "delete"
+      /* DELETE */
+      , key, undefined, oldValue);
+    }
+
+    return result;
+  }
+
+  function clear() {
+    var target = toRaw(this);
+    var hadItems = target.size !== 0;
+    var oldTarget = isMap$1(target) ? new Map(target) : new Set(target); // forward the operation before queueing reactions
+
+    var result = target.clear();
+
+    if (hadItems) {
+      trigger(target, "clear"
+      /* CLEAR */
+      , undefined, undefined, oldTarget);
+    }
+
+    return result;
+  }
 
-        get size() {
-            return size(this);
-        },
+  function createForEach(isReadonly, isShallow) {
+    return function forEach(callback, thisArg) {
+      var observed = this;
+      var target = observed["__v_raw"
+      /* RAW */
+      ];
+      var rawTarget = toRaw(target);
+      var wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
+      !isReadonly && track(rawTarget, "iterate"
+      /* ITERATE */
+      , ITERATE_KEY);
+      return target.forEach(function (value, key) {
+        // important: make sure the callback is
+        // 1. invoked with the reactive map as `this` and 3rd arg
+        // 2. the value received should be a corresponding reactive/readonly.
+        return callback.call(thisArg, wrap(value), wrap(key), observed);
+      });
+    };
+  }
+
+  function createIterableMethod(method, isReadonly, isShallow) {
+    return function () {
+      var target = this["__v_raw"
+      /* RAW */
+      ];
+      var rawTarget = toRaw(target);
+      var targetIsMap = isMap$1(rawTarget);
+      var isPair = method === 'entries' || method === Symbol.iterator && targetIsMap;
+      var isKeyOnly = method === 'keys' && targetIsMap;
+      var innerIterator = target[method].apply(target, arguments);
+      var wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
+      !isReadonly && track(rawTarget, "iterate"
+      /* ITERATE */
+      , isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY); // return a wrapped iterator which returns observed versions of the
+      // values emitted from the real iterator
+
+      return _defineProperty({
+        // iterator protocol
+        next: function next() {
+          var _innerIterator$next = innerIterator.next(),
+              value = _innerIterator$next.value,
+              done = _innerIterator$next.done;
+
+          return done ? {
+            value: value,
+            done: done
+          } : {
+            value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),
+            done: done
+          };
+        }
+      }, Symbol.iterator, function () {
+        return this;
+      });
+    };
+  }
+
+  function createReadonlyMethod(type) {
+    return function () {
+      {
+        var key = (arguments.length <= 0 ? undefined : arguments[0]) ? "on key \"".concat(arguments.length <= 0 ? undefined : arguments[0], "\" ") : "";
+        console.warn("".concat(capitalize(type), " operation ").concat(key, "failed: target is readonly."), toRaw(this));
+      }
+      return type === "delete"
+      /* DELETE */
+      ? false : this;
+    };
+  }
 
-        has: has$1$1,
-        add: add,
-        set: set$1$1,
-        delete: deleteEntry,
-        clear: clear,
-        forEach: createForEach(false, false)
+  function createInstrumentations() {
+    var mutableInstrumentations = {
+      get: function get(key) {
+        return get$1(this, key);
+      },
+
+      get size() {
+        return size(this);
+      },
+
+      has: has$1$1,
+      add: add,
+      set: set$1$1,
+      delete: deleteEntry,
+      clear: clear,
+      forEach: createForEach(false, false)
     };
     var shallowInstrumentations = {
-        get: function get(key) {
-            return get$1(this, key, false, true);
-        },
-
-        get size() {
-            return size(this);
-        },
-
-        has: has$1$1,
-        add: add,
-        set: set$1$1,
-        delete: deleteEntry,
-        clear: clear,
-        forEach: createForEach(false, true)
+      get: function get(key) {
+        return get$1(this, key, false, true);
+      },
+
+      get size() {
+        return size(this);
+      },
+
+      has: has$1$1,
+      add: add,
+      set: set$1$1,
+      delete: deleteEntry,
+      clear: clear,
+      forEach: createForEach(false, true)
     };
     var readonlyInstrumentations = {
-        get: function get(key) {
-            return get$1(this, key, true);
-        },
-
-        get size() {
-            return size(this, true);
-        },
-
-        has: function has(key) {
-            return has$1$1.call(this, key, true);
-        },
-        add: createReadonlyMethod("add"
-            /* ADD */
-        ),
-        set: createReadonlyMethod("set"
-            /* SET */
-        ),
-        delete: createReadonlyMethod("delete"
-            /* DELETE */
-        ),
-        clear: createReadonlyMethod("clear"
-            /* CLEAR */
-        ),
-        forEach: createForEach(true, false)
+      get: function get(key) {
+        return get$1(this, key, true);
+      },
+
+      get size() {
+        return size(this, true);
+      },
+
+      has: function has(key) {
+        return has$1$1.call(this, key, true);
+      },
+      add: createReadonlyMethod("add"
+      /* ADD */
+      ),
+      set: createReadonlyMethod("set"
+      /* SET */
+      ),
+      delete: createReadonlyMethod("delete"
+      /* DELETE */
+      ),
+      clear: createReadonlyMethod("clear"
+      /* CLEAR */
+      ),
+      forEach: createForEach(true, false)
+    };
+    var shallowReadonlyInstrumentations = {
+      get: function get(key) {
+        return get$1(this, key, true, true);
+      },
+
+      get size() {
+        return size(this, true);
+      },
+
+      has: function has(key) {
+        return has$1$1.call(this, key, true);
+      },
+      add: createReadonlyMethod("add"
+      /* ADD */
+      ),
+      set: createReadonlyMethod("set"
+      /* SET */
+      ),
+      delete: createReadonlyMethod("delete"
+      /* DELETE */
+      ),
+      clear: createReadonlyMethod("clear"
+      /* CLEAR */
+      ),
+      forEach: createForEach(true, true)
     };
-    var iteratorMethods = ["keys", "values", "entries", Symbol.iterator];
+    var iteratorMethods = ['keys', 'values', 'entries', Symbol.iterator];
     iteratorMethods.forEach(function (method) {
-        mutableInstrumentations[method] = createIterableMethod(method, false, false);
-        readonlyInstrumentations[method] = createIterableMethod(method, true, false);
-        shallowInstrumentations[method] = createIterableMethod(method, false, true);
+      mutableInstrumentations[method] = createIterableMethod(method, false, false);
+      readonlyInstrumentations[method] = createIterableMethod(method, true, false);
+      shallowInstrumentations[method] = createIterableMethod(method, false, true);
+      shallowReadonlyInstrumentations[method] = createIterableMethod(method, true, true);
     });
-
-    function createInstrumentationGetter(isReadonly, shallow) {
-        var instrumentations = shallow ? shallowInstrumentations : isReadonly ? readonlyInstrumentations : mutableInstrumentations;
-        return function (target, key, receiver) {
-            if (key === "__v_isReactive"
-                /* IS_REACTIVE */
-            ) {
-                return !isReadonly;
-            } else if (key === "__v_isReadonly"
-                /* IS_READONLY */
-            ) {
-                return isReadonly;
-            } else if (key === "__v_raw"
-                /* RAW */
-            ) {
-                return target;
-            }
-
-            return Reflect.get(hasOwn(instrumentations, key) && key in target ? instrumentations : target, key, receiver);
-        };
-    }
-
-    var mutableCollectionHandlers = {
-        get: createInstrumentationGetter(false, false)
+    return [mutableInstrumentations, readonlyInstrumentations, shallowInstrumentations, shallowReadonlyInstrumentations];
+  }
+
+  var _createInstrumentatio = /* #__PURE__*/createInstrumentations(),
+      _createInstrumentatio2 = _slicedToArray(_createInstrumentatio, 4),
+      mutableInstrumentations = _createInstrumentatio2[0],
+      readonlyInstrumentations = _createInstrumentatio2[1],
+      shallowInstrumentations = _createInstrumentatio2[2],
+      shallowReadonlyInstrumentations = _createInstrumentatio2[3];
+
+  function createInstrumentationGetter(isReadonly, shallow) {
+    var instrumentations = shallow ? isReadonly ? shallowReadonlyInstrumentations : shallowInstrumentations : isReadonly ? readonlyInstrumentations : mutableInstrumentations;
+    return function (target, key, receiver) {
+      if (key === "__v_isReactive"
+      /* IS_REACTIVE */
+      ) {
+          return !isReadonly;
+        } else if (key === "__v_isReadonly"
+      /* IS_READONLY */
+      ) {
+          return isReadonly;
+        } else if (key === "__v_raw"
+      /* RAW */
+      ) {
+          return target;
+        }
+
+      return Reflect.get(hasOwn(instrumentations, key) && key in target ? instrumentations : target, key, receiver);
     };
-    var readonlyCollectionHandlers = {
-        get: createInstrumentationGetter(true, false)
-    };
-
-    function checkIdentityKeys(target, has, key) {
-        var rawKey = toRaw(key);
-
-        if (rawKey !== key && has.call(target, rawKey)) {
-            var type = toRawType(target);
-            console.warn("Reactive ".concat(type, " contains both the raw and reactive ") + "versions of the same object".concat(type === "Map" ? " as keys" : "", ", ") + "which can lead to inconsistencies. " + "Avoid differentiating between the raw and reactive versions " + "of an object and only use the reactive version if possible.");
-        }
+  }
+
+  var mutableCollectionHandlers = {
+    get: /*#__PURE__*/createInstrumentationGetter(false, false)
+  };
+  var readonlyCollectionHandlers = {
+    get: /*#__PURE__*/createInstrumentationGetter(true, false)
+  };
+
+  function checkIdentityKeys(target, has, key) {
+    var rawKey = toRaw(key);
+
+    if (rawKey !== key && has.call(target, rawKey)) {
+      var type = toRawType(target);
+      console.warn("Reactive ".concat(type, " contains both the raw and reactive ") + "versions of the same object".concat(type === "Map" ? " as keys" : "", ", ") + "which can lead to inconsistencies. " + "Avoid differentiating between the raw and reactive versions " + "of an object and only use the reactive version if possible.");
+    }
+  }
+
+  var reactiveMap = new WeakMap();
+  var shallowReactiveMap = new WeakMap();
+  var readonlyMap = new WeakMap();
+  var shallowReadonlyMap = new WeakMap();
+
+  function targetTypeMap(rawType) {
+    switch (rawType) {
+      case 'Object':
+      case 'Array':
+        return 1
+        /* COMMON */
+        ;
+
+      case 'Map':
+      case 'Set':
+      case 'WeakMap':
+      case 'WeakSet':
+        return 2
+        /* COLLECTION */
+        ;
+
+      default:
+        return 0
+        /* INVALID */
+        ;
+    }
+  }
+
+  function getTargetType(value) {
+    return value["__v_skip"
+    /* SKIP */
+    ] || !Object.isExtensible(value) ? 0
+    /* INVALID */
+    : targetTypeMap(toRawType(value));
+  }
+
+  function reactive(target) {
+    // if trying to observe a readonly proxy, return the readonly version.
+    if (target && target["__v_isReadonly"
+    /* IS_READONLY */
+    ]) {
+      return target;
+    }
+
+    return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers, reactiveMap);
+  }
+  /**
+   * Creates a readonly copy of the original object. Note the returned copy is not
+   * made reactive, but `readonly` can be called on an already reactive object.
+   */
+
+
+  function readonly(target) {
+    return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers, readonlyMap);
+  }
+
+  function createReactiveObject(target, isReadonly, baseHandlers, collectionHandlers, proxyMap) {
+    if (!isObject(target)) {
+      {
+        console.warn("value cannot be made reactive: ".concat(String(target)));
+      }
+      return target;
+    } // target is already a Proxy, return it.
+    // exception: calling readonly() on a reactive object
+
+
+    if (target["__v_raw"
+    /* RAW */
+    ] && !(isReadonly && target["__v_isReactive"
+    /* IS_REACTIVE */
+    ])) {
+      return target;
+    } // target already has corresponding Proxy
+
+
+    var existingProxy = proxyMap.get(target);
+
+    if (existingProxy) {
+      return existingProxy;
+    } // only a whitelist of value types can be observed.
+
+
+    var targetType = getTargetType(target);
+
+    if (targetType === 0
+    /* INVALID */
+    ) {
+        return target;
+      }
+
+    var proxy = new Proxy(target, targetType === 2
+    /* COLLECTION */
+    ? collectionHandlers : baseHandlers);
+    proxyMap.set(target, proxy);
+    return proxy;
+  }
+
+  function isReactive(value) {
+    if (isReadonly(value)) {
+      return isReactive(value["__v_raw"
+      /* RAW */
+      ]);
+    }
+
+    return !!(value && value["__v_isReactive"
+    /* IS_REACTIVE */
+    ]);
+  }
+
+  function isReadonly(value) {
+    return !!(value && value["__v_isReadonly"
+    /* IS_READONLY */
+    ]);
+  }
+
+  function toRaw(observed) {
+    var raw = observed && observed["__v_raw"
+    /* RAW */
+    ];
+    return raw ? toRaw(raw) : observed;
+  }
+
+  var toReactive = function toReactive(value) {
+    return isObject(value) ? reactive(value) : value;
+  };
+
+  var toReadonly = function toReadonly(value) {
+    return isObject(value) ? readonly(value) : value;
+  };
+
+  function trackRefValue(ref) {
+    if (isTracking()) {
+      ref = toRaw(ref);
+
+      if (!ref.dep) {
+        ref.dep = createDep();
+      }
+
+      {
+        trackEffects(ref.dep, {
+          target: ref,
+          type: "get"
+          /* GET */
+          ,
+          key: 'value'
+        });
+      }
+    }
+  }
+
+  function triggerRefValue(ref, newVal) {
+    ref = toRaw(ref);
+
+    if (ref.dep) {
+      {
+        triggerEffects(ref.dep, {
+          target: ref,
+          type: "set"
+          /* SET */
+          ,
+          key: 'value',
+          newValue: newVal
+        });
+      }
     }
+  }
 
-    var reactiveMap = new WeakMap();
-    var readonlyMap = new WeakMap();
+  function isRef(r) {
+    return Boolean(r && r.__v_isRef === true);
+  }
 
-    function targetTypeMap(rawType) {
-        switch (rawType) {
-            case "Object":
-            case "Array":
-                return 1;
+  var ComputedRefImpl = /*#__PURE__*/function () {
+    function ComputedRefImpl(getter, _setter, isReadonly) {
+      var _this2 = this;
 
-            case "Map":
-            case "Set":
-            case "WeakMap":
-            case "WeakSet":
-                return 2;
+      _classCallCheck(this, ComputedRefImpl);
 
-            default:
-                return 0;
+      this._setter = _setter;
+      this.dep = undefined;
+      this._dirty = true;
+      this.__v_isRef = true;
+      this.effect = new ReactiveEffect(getter, function () {
+        if (!_this2._dirty) {
+          _this2._dirty = true;
+          triggerRefValue(_this2);
         }
-    }
-
-    function getTargetType(value) {
-        return value["__v_skip"
-            /* SKIP */
-            ] || !Object.isExtensible(value) ? 0
-            /* INVALID */
-            : targetTypeMap(toRawType(value));
-    }
+      });
+      this["__v_isReadonly"
+      /* IS_READONLY */
+      ] = isReadonly;
+    }
+
+    _createClass(ComputedRefImpl, [{
+      key: "value",
+      get: function get() {
+        // the computed ref may get wrapped by other proxies e.g. readonly() #3376
+        var self = toRaw(this);
+        trackRefValue(self);
+
+        if (self._dirty) {
+          self._dirty = false;
+          self._value = self.effect.run();
+        }
+
+        return self._value;
+      },
+      set: function set(newValue) {
+        this._setter(newValue);
+      }
+    }]);
+
+    return ComputedRefImpl;
+  }();
+
+  function computed(getterOrOptions, debugOptions) {
+    var getter;
+    var setter;
+    var onlyGetter = isFunction(getterOrOptions);
+
+    if (onlyGetter) {
+      getter = getterOrOptions;
+
+      setter = function setter() {
+        console.warn('Write operation failed: computed value is readonly');
+      };
+    } else {
+      getter = getterOrOptions.get;
+      setter = getterOrOptions.set;
+    }
+
+    var cRef = new ComputedRefImpl(getter, setter, onlyGetter || !setter);
+
+    if (debugOptions) {
+      cRef.effect.onTrack = debugOptions.onTrack;
+      cRef.effect.onTrigger = debugOptions.onTrigger;
+    }
+
+    return cRef;
+  }
+
+  function noop() {}
+  function isNative(Ctor) {
+    return typeof Ctor === "function" && /native code/.test(Ctor.toString());
+  }
+  var isIE = function isIE() {
+    if (typeof navigator === "undefined") {
+      return false;
+    }
+
+    return /(msie|trident)/i.test(navigator.userAgent.toLowerCase());
+  };
+  var getIEVersion = function getIEVersion() {
+    var version = 0;
+
+    if (typeof navigator === "undefined") {
+      return false;
+    }
+
+    var agent = navigator.userAgent.toLowerCase();
+    var v1 = agent.match(/(?:msie\s([\w.]+))/);
+    var v2 = agent.match(/(?:trident.*rv:([\w.]+))/);
+
+    if (v1 && v2 && v1[1] && v2[1]) {
+      version = Math.max(v1[1] * 1, v2[1] * 1);
+    } else if (v1 && v1[1]) {
+      version = v1[1] * 1;
+    } else if (v2 && v2[1]) {
+      version = v2[1] * 1;
+    } else {
+      version = 0;
+    }
+
+    return version;
+  };
+  isIE() && getIEVersion() < 9;
+  var _toString = Object.prototype.toString;
+  function isPlainObject(obj) {
+    return _toString.call(obj) === "[object Object]";
+  }
+
+  function parsePath(path) {
+    // if (bailRE.test(path)) {
+    // return;
+    // }
+    var segments = path.length > 0 ? path.split(".") : [];
+    return function (obj) {
+      for (var i = 0; i < segments.length; i++) {
+        if (!obj) return;
+        obj = obj[segments[i]];
+      }
 
-    function reactive(target) {
-        // if trying to observe a readonly proxy, return the readonly version.
-        if (target && target["__v_isReadonly"
-            /* IS_READONLY */
-            ]) {
-            return target;
+      return obj;
+    };
+  }
+  var nextTick = function () {
+    var callbacks = [];
+    var pending = false;
+    var timerFunc;
+
+    function nextTickHandler() {
+      pending = false;
+      var copies = callbacks.slice(0);
+      callbacks.length = 0;
+
+      for (var i = 0; i < copies.length; i++) {
+        copies[i]();
+      }
+    } // An asynchronous deferring mechanism.
+    // In pre 2.4, we used to use microtasks (Promise/MutationObserver)
+    // but microtasks actually has too high a priority and fires in between
+    // supposedly sequential events (e.g. #4521, #6690) or even between
+    // bubbling of the same event (#6566). Technically setImmediate should be
+    // the ideal choice, but it's not available everywhere; and the only polyfill
+    // that consistently queues the callback after all DOM events triggered in the
+    // same loop is by using MessageChannel.
+
+    /* istanbul ignore if */
+
+
+    if (typeof setImmediate !== "undefined" && isNative(setImmediate)) {
+      timerFunc = function timerFunc() {
+        setImmediate(nextTickHandler);
+      };
+    } else if (typeof MessageChannel !== "undefined" && (isNative(MessageChannel) || // PhantomJS
+    MessageChannel.toString() === "[object MessageChannelConstructor]")) {
+      var channel = new MessageChannel();
+      var port = channel.port2;
+      channel.port1.onmessage = nextTickHandler;
+
+      timerFunc = function timerFunc() {
+        port.postMessage(1);
+      };
+    } else if (typeof Promise !== "undefined" && isNative(Promise)) {
+      /* istanbul ignore next */
+      // use microtask in non-DOM environments, e.g. Weex
+      var p = Promise.resolve();
+
+      timerFunc = function timerFunc() {
+        p.then(nextTickHandler);
+      };
+    } else {
+      // fallback to setTimeout
+      timerFunc = function timerFunc() {
+        setTimeout(nextTickHandler, 0);
+      };
+    }
+
+    return function queueNextTick(cb, ctx) {
+      var _resolve;
+
+      callbacks.push(function () {
+        if (cb) {
+          try {
+            cb.call(ctx);
+          } catch (e) {
+            console.error(e);
+          }
+        } else if (_resolve) {
+          _resolve(ctx);
         }
+      });
 
-        return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers);
-    } // Return a reactive-copy of the original object, where only the root level
-
-    function readonly(target) {
-        return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers);
-    } // Return a reactive-copy of the original object, where only the root level
-
-    function createReactiveObject(target, isReadonly, baseHandlers, collectionHandlers) {
-        if (!isObject(target)) {
-            {
-                console.warn("value cannot be made reactive: ".concat(String(target)));
-            }
-            return target;
-        } // target is already a Proxy, return it.
-        // exception: calling readonly() on a reactive object
-
-
-        if (target["__v_raw"
-            /* RAW */
-            ] && !(isReadonly && target["__v_isReactive"
-            /* IS_REACTIVE */
-            ])) {
-            return target;
-        } // target already has corresponding Proxy
-
-
-        var proxyMap = isReadonly ? readonlyMap : reactiveMap;
-        var existingProxy = proxyMap.get(target);
-
-        if (existingProxy) {
-            return existingProxy;
-        } // only a whitelist of value types can be observed.
+      if (!pending) {
+        pending = true;
+        timerFunc();
+      } // $flow-disable-line
 
 
-        var targetType = getTargetType(target);
-
-        if (targetType === 0
-            /* INVALID */
-        ) {
-            return target;
-        }
-
-        var proxy = new Proxy(target, targetType === 2
-            /* COLLECTION */
-            ? collectionHandlers : baseHandlers);
-        proxyMap.set(target, proxy);
-        return proxy;
-    }
+      if (!cb && typeof Promise !== "undefined") {
+        return new Promise(function (resolve) {
+          _resolve = resolve;
+        });
+      }
+    };
+  }();
+
+  var mixinInjection = {};
+  function getMixins(type) {
+    return mixinInjection[type];
+  }
+  function mixin(xtype, cls) {
+    mixinInjection[xtype] = _.cloneDeep(cls);
+  }
+
+  var queue = [];
+  var activatedChildren = [];
+  var has = {};
+  var waiting = false;
+  var flushing = false;
+  var index = 0;
+
+  function resetSchedulerState() {
+    index = queue.length = activatedChildren.length = 0;
+    has = {};
+    waiting = flushing = false;
+  }
+
+  function flushSchedulerQueue() {
+    flushing = true;
+    var watcher;
+    var id;
+    var options; // 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(function (a, b) {
+      return 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].watcher;
+      options = queue[index].options;
+      id = watcher.id;
+      has[id] = null;
+      watcher(options);
+    }
+
+    resetSchedulerState();
+  }
+
+  function queueWatcher(watcher, options) {
+    var id = watcher.id;
+
+    if (has[id] == null) {
+      has[id] = true;
+
+      if (!flushing) {
+        queue.push({
+          watcher: watcher,
+          options: options
+        });
+      } else {
+        // if already flushing, splice the watcher based on its id
+        // if already past its id, it will be run next immediately.
+        var i = queue.length - 1;
 
-    function isReactive(value) {
-        if (isReadonly(value)) {
-            return isReactive(value["__v_raw"
-                /* RAW */
-                ]);
+        while (i > index && queue[i].watcher.id > watcher.id) {
+          i--;
         }
 
-        return !!(value && value["__v_isReactive"
-            /* IS_REACTIVE */
-            ]);
-    }
+        queue.splice(i + 1, 0, {
+          watcher: watcher,
+          options: options
+        });
+      } // queue the flush
 
-    function isReadonly(value) {
-        return !!(value && value["__v_isReadonly"
-            /* IS_READONLY */
-            ]);
-    }
 
-    function toRaw(observed) {
-        return observed && toRaw(observed["__v_raw"
-            /* RAW */
-            ]) || observed;
+      if (!waiting) {
+        waiting = true;
+        nextTick(flushSchedulerQueue);
+      }
     }
+  }
 
-    function isRef(r) {
-        return Boolean(r && r.__v_isRef === true);
+  function innerWatch(source, cb, options) {
+    if (!_.isFunction(cb)) {
+      console.warn("`watch(fn, options?)` signature has been moved to a separate API. " + "Use `watchEffect(fn, options?)` instead. `watch` now only " + "supports `watch(source, cb, options?) signature.");
     }
 
-    var ComputedRefImpl = /*#__PURE__*/function () {
-        function ComputedRefImpl(getter, _setter, isReadonly) {
-            var _this2 = this;
+    return doWatch(source, cb, options);
+  }
+  var INITIAL_WATCHER_VALUE = {};
+  var objectToString = Object.prototype.toString;
 
-            _classCallCheck(this, ComputedRefImpl);
+  var toTypeString = function toTypeString(value) {
+    return objectToString.call(value);
+  };
 
-            this._setter = _setter;
-            this._dirty = true;
-            this.__v_isRef = true;
-            this.effect = effect(getter, {
-                lazy: true,
-                scheduler: function scheduler() {
-                    if (!_this2._dirty) {
-                        _this2._dirty = true;
-                        trigger(toRaw(_this2), "set"
-                            /* SET */
-                            , "value");
-                    }
-                }
-            });
-            this["__v_isReadonly"
-                /* IS_READONLY */
-                ] = isReadonly;
-        }
+  var isMap = function isMap(val) {
+    return toTypeString(val) === "[object Map]";
+  };
 
-        _createClass(ComputedRefImpl, [{
-            key: "value",
-            get: function get() {
-                if (this._dirty) {
-                    this._value = this.effect();
-                    this._dirty = false;
-                }
-
-                track(toRaw(this), "get"
-                    /* GET */
-                    , "value");
-                return this._value;
-            },
-            set: function set(newValue) {
-                this._setter(newValue);
-            }
-        }]);
+  var isSet = function isSet(val) {
+    return toTypeString(val) === "[object Set]";
+  };
 
-        return ComputedRefImpl;
-    }();
+  var hasChanged = function hasChanged(value, oldValue) {
+    return value !== oldValue && (value === value || oldValue === oldValue);
+  };
 
-    function computed(getterOrOptions) {
-        var getter;
-        var setter;
+  var uid = 0;
 
-        if (isFunction(getterOrOptions)) {
-            getter = getterOrOptions;
+  function doWatch(source, cb, options, instance) {
+    options = options || {};
+    var _options = options,
+        immediate = _options.immediate,
+        deep = _options.deep,
+        sync = _options.sync,
+        onTrack = _options.onTrack,
+        onTrigger = _options.onTrigger;
 
-            setter = function setter() {
-                console.warn("Write operation failed: computed value is readonly");
-            };
-        } else {
-            getter = getterOrOptions.get;
-            setter = getterOrOptions.set;
-        }
+    if (!cb) {
+      if (immediate !== undefined) {
+        console.warn("watch() \"immediate\" option is only respected when using the " + "watch(source, callback, options?) signature.");
+      }
 
-        return new ComputedRefImpl(getter, setter, isFunction(getterOrOptions) || !getterOrOptions.set);
+      if (deep !== undefined) {
+        console.warn("watch() \"deep\" option is only respected when using the " + "watch(source, callback, options?) signature.");
+      }
     }
 
-    function noop() {}
-    function isNative(Ctor) {
-        return typeof Ctor === "function" && /native code/.test(Ctor.toString());
-    }
-    var isIE = function isIE() {
-        if (typeof navigator === "undefined") {
-            return false;
-        }
-
-        return /(msie|trident)/i.test(navigator.userAgent.toLowerCase());
+    var warnInvalidSource = function warnInvalidSource(s) {
+      console.warn("Invalid watch source: ", s, "A watch source can only be a getter/effect function, a ref, " + "a reactive object, or an array of these types.");
     };
-    var getIEVersion = function getIEVersion() {
-        var version = 0;
 
-        if (typeof navigator === "undefined") {
-            return false;
-        }
-
-        var agent = navigator.userAgent.toLowerCase();
-        var v1 = agent.match(/(?:msie\s([\w.]+))/);
-        var v2 = agent.match(/(?:trident.*rv:([\w.]+))/);
-
-        if (v1 && v2 && v1[1] && v2[1]) {
-            version = Math.max(v1[1] * 1, v2[1] * 1);
-        } else if (v1 && v1[1]) {
-            version = v1[1] * 1;
-        } else if (v2 && v2[1]) {
-            version = v2[1] * 1;
-        } else {
-            version = 0;
-        }
-
-        return version;
-    };
-    isIE() && getIEVersion() < 9;
-    var _toString = Object.prototype.toString;
-    function isPlainObject(obj) {
-        return _toString.call(obj) === "[object Object]";
-    }
-    var bailRE = /[^\w.$]/;
-    function parsePath(path) {
-        if (bailRE.test(path)) {
-            return;
-        }
-
-        var segments = path.split(".");
-        return function (obj) {
-            for (var i = 0; i < segments.length; i++) {
-                if (!obj) return;
-                obj = obj[segments[i]];
-            }
-
-            return obj;
+    var getter;
+    var forceTrigger = false;
+
+    if (isRef(source)) {
+      getter = function getter() {
+        return source.value;
+      };
+
+      forceTrigger = !!source._shallow;
+    } else if (isReactive(source)) {
+      getter = function getter() {
+        return source;
+      };
+
+      deep = true;
+    } else if (_.isArray(source)) {
+      getter = function getter() {
+        return source.map(function (s) {
+          if (isRef(s)) {
+            return s.value;
+          } else if (isReactive(s)) {
+            return traverse(s);
+          } else if (_.isFunction(s)) {
+            return s.call(instance);
+          } else {
+            warnInvalidSource(s);
+          }
+        });
+      };
+    } else if (_.isFunction(source)) {
+      if (cb) {
+        // getter with cb
+        getter = function getter() {
+          return source.call(instance);
         };
-    }
-    var nextTick = function () {
-        var callbacks = [];
-        var pending = false;
-        var timerFunc;
-
-        function nextTickHandler() {
-            pending = false;
-            var copies = callbacks.slice(0);
-            callbacks.length = 0;
-
-            for (var i = 0; i < copies.length; i++) {
-                copies[i]();
-            }
-        } // An asynchronous deferring mechanism.
-        // In pre 2.4, we used to use microtasks (Promise/MutationObserver)
-        // but microtasks actually has too high a priority and fires in between
-        // supposedly sequential events (e.g. #4521, #6690) or even between
-        // bubbling of the same event (#6566). Technically setImmediate should be
-        // the ideal choice, but it's not available everywhere; and the only polyfill
-        // that consistently queues the callback after all DOM events triggered in the
-        // same loop is by using MessageChannel.
-
-        /* istanbul ignore if */
-
-
-        if (typeof setImmediate !== "undefined" && isNative(setImmediate)) {
-            timerFunc = function timerFunc() {
-                setImmediate(nextTickHandler);
-            };
-        } else if (typeof MessageChannel !== "undefined" && (isNative(MessageChannel) || // PhantomJS
-            MessageChannel.toString() === "[object MessageChannelConstructor]")) {
-            var channel = new MessageChannel();
-            var port = channel.port2;
-            channel.port1.onmessage = nextTickHandler;
-
-            timerFunc = function timerFunc() {
-                port.postMessage(1);
-            };
-        } else if (typeof Promise !== "undefined" && isNative(Promise)) {
-            /* istanbul ignore next */
-            // use microtask in non-DOM environments, e.g. Weex
-            var p = Promise.resolve();
-
-            timerFunc = function timerFunc() {
-                p.then(nextTickHandler);
-            };
-        } else {
-            // fallback to setTimeout
-            timerFunc = function timerFunc() {
-                setTimeout(nextTickHandler, 0);
-            };
-        }
-
-        return function queueNextTick(cb, ctx) {
-            var _resolve;
-
-            callbacks.push(function () {
-                if (cb) {
-                    try {
-                        cb.call(ctx);
-                    } catch (e) {
-                        console.error(e);
-                    }
-                } else if (_resolve) {
-                    _resolve(ctx);
-                }
-            });
-
-            if (!pending) {
-                pending = true;
-                timerFunc();
-            } // $flow-disable-line
+      } else {
+        // no cb -> simple effect
+        getter = function getter() {
+          if (instance && instance.isUnmounted) {
+            return;
+          }
 
+          if (cleanup) {
+            cleanup();
+          }
 
-            if (!cb && typeof Promise !== "undefined") {
-                return new Promise(function (resolve) {
-                    _resolve = resolve;
-                });
-            }
+          return source.call(instance, onInvalidate);
         };
-    }();
-
-    var mixinInjection = {};
-    function getMixins(type) {
-        return mixinInjection[type];
-    }
-    function mixin(xtype, cls) {
-        mixinInjection[xtype] = _.cloneDeep(cls);
-    }
-
-    var queue = [];
-    var activatedChildren = [];
-    var has = {};
-    var waiting = false;
-    var flushing = false;
-    var index = 0;
-
-    function resetSchedulerState() {
-        index = queue.length = activatedChildren.length = 0;
-        has = {};
-        waiting = flushing = false;
-    }
-
-    function flushSchedulerQueue() {
-        flushing = true;
-        var watcher;
-        var id;
-        var options; // 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(function (a, b) {
-            return 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].watcher;
-            options = queue[index].options;
-            id = watcher.id;
-            has[id] = null;
-            watcher(options);
-        }
+      }
+    } else {
+      getter = function getter() {};
 
-        resetSchedulerState();
+      warnInvalidSource(source);
     }
 
-    function queueWatcher(watcher, options) {
-        var id = watcher.id;
-
-        if (has[id] == null) {
-            has[id] = true;
-
-            if (!flushing) {
-                queue.push({
-                    watcher: watcher,
-                    options: options
-                });
-            } else {
-                // if already flushing, splice the watcher based on its id
-                // if already past its id, it will be run next immediately.
-                var i = queue.length - 1;
-
-                while (i > index && queue[i].watcher.id > watcher.id) {
-                    i--;
-                }
-
-                queue.splice(i + 1, 0, {
-                    watcher: watcher,
-                    options: options
-                });
-            } // queue the flush
+    if (cb && deep) {
+      var baseGetter = getter;
 
-
-            if (!waiting) {
-                waiting = true;
-                nextTick(flushSchedulerQueue);
-            }
-        }
+      getter = function getter() {
+        return traverse(baseGetter());
+      };
     }
 
-    function innerWatch(source, cb, options) {
-        if (!_.isFunction(cb)) {
-            console.warn("`watch(fn, options?)` signature has been moved to a separate API. " + "Use `watchEffect(fn, options?)` instead. `watch` now only " + "supports `watch(source, cb, options?) signature.");
-        }
+    var cleanup;
 
-        return doWatch(source, cb, options);
-    }
-    var INITIAL_WATCHER_VALUE = {};
-    var objectToString = Object.prototype.toString;
-
-    var toTypeString = function toTypeString(value) {
-        return objectToString.call(value);
+    var onInvalidate = function onInvalidate(fn) {
+      cleanup = runner.options.onStop = function () {
+        fn.call(instance);
+      };
     };
 
-    var isMap = function isMap(val) {
-        return toTypeString(val) === "[object Map]";
+    var oldValue = _.isArray(source) ? [] : INITIAL_WATCHER_VALUE;
+
+    var job = function job() {
+      // 这里去掉的原因是，新增属性没有生效也会触发变化监听
+      // if (!runner.active) {
+      //   return;
+      // }
+      if (cb) {
+        // watch(source, cb)
+        var newValue = runner();
+
+        if (deep || forceTrigger || hasChanged(newValue, oldValue)) {
+          // cleanup before running cb again
+          if (cleanup) {
+            cleanup();
+          }
+
+          cb.apply(instance, [newValue, // pass undefined as the old value when it's changed for the first time
+          oldValue === INITIAL_WATCHER_VALUE ? undefined : oldValue, onInvalidate]);
+          oldValue = newValue;
+        }
+      } else {
+        // watchEffect
+        runner();
+      }
+    }; // important: mark the job as a watcher callback so that scheduler knows
+    // it is allowed to self-trigger (#1727)
+
+
+    job.allowRecurse = !!cb;
+    job.id = ++uid;
+    var scheduler;
+
+    if (sync === true) {
+      scheduler = job;
+    } else {
+      scheduler = function scheduler() {
+        return queueWatcher(job);
+      };
+    }
+
+    var runner = effect(function () {
+      try {
+        return getter();
+      } catch (e) {// 吞掉异常
+      }
+    }, {
+      lazy: true,
+      onTrack: onTrack,
+      onTrigger: onTrigger,
+      scheduler: scheduler
+    }); // initial run
+
+    if (cb) {
+      if (immediate) {
+        job();
+      } else {
+        oldValue = runner();
+      }
+    } else {
+      runner();
+    }
+
+    return function () {
+      stop(runner);
     };
+  }
 
-    var isSet = function isSet(val) {
-        return toTypeString(val) === "[object Set]";
-    };
+  function traverse(value) {
+    var seen = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Set();
 
-    var hasChanged = function hasChanged(value, oldValue) {
-        return value !== oldValue && (value === value || oldValue === oldValue);
-    };
+    if (!_.isObject(value) || seen.has(value)) {
+      return value;
+    }
 
-    var uid = 0;
+    seen.add(value);
 
-    function doWatch(source, cb, options, instance) {
-        options = options || {};
-        var _options = options,
-            immediate = _options.immediate,
-            deep = _options.deep,
-            sync = _options.sync,
-            onTrack = _options.onTrack,
-            onTrigger = _options.onTrigger;
+    if (isRef(value)) {
+      traverse(value.value, seen);
+    } else if (_.isArray(value)) {
+      for (var i = 0; i < value.length; i++) {
+        traverse(value[i], seen);
+      }
+    } else if (isSet(value) || isMap(value)) {
+      value.forEach(function (v) {
+        traverse(v, seen);
+      });
+    } else {
+      for (var key in value) {
+        traverse(value[key], seen);
+      }
+    }
 
-        if (!cb) {
-            if (immediate !== undefined) {
-                console.warn("watch() \"immediate\" option is only respected when using the " + "watch(source, callback, options?) signature.");
-            }
+    return value;
+  }
 
-            if (deep !== undefined) {
-                console.warn("watch() \"deep\" option is only respected when using the " + "watch(source, callback, options?) signature.");
-            }
-        }
+  var falsy;
+  var operators = {
+    "||": falsy,
+    "&&": falsy,
+    "(": falsy,
+    ")": falsy
+  };
 
-        var warnInvalidSource = function warnInvalidSource(s) {
-            console.warn("Invalid watch source: ", s, "A watch source can only be a getter/effect function, a ref, " + "a reactive object, or an array of these types.");
-        };
+  function runBinaryFunction(binarys) {
+    var expr = "";
 
-        var getter;
-        var forceTrigger = false;
+    for (var i = 0, len = binarys.length; i < len; i++) {
+      if (_.isBoolean(binarys[i]) || _.has(operators, binarys[i])) {
+        expr += binarys[i];
+      } else {
+        expr += "false";
+      }
+    }
 
-        if (isRef(source)) {
-            getter = function getter() {
-                return source.value;
-            };
+    return new Function("return " + expr)();
+  }
 
-            forceTrigger = !!source._shallow;
-        } else if (isReactive(source)) {
-            getter = function getter() {
-                return source;
-            };
+  function watchExp(model, getter) {
+    var result = getter.call(model, model);
 
-            deep = true;
-        } else if (_.isArray(source)) {
-            getter = function getter() {
-                return source.map(function (s) {
-                    if (isRef(s)) {
-                        return s.value;
-                    } else if (isReactive(s)) {
-                        return traverse(s);
-                    } else if (_.isFunction(s)) {
-                        return s.call(instance);
-                    } else {
-                        warnInvalidSource(s);
-                    }
-                });
-            };
-        } else if (_.isFunction(source)) {
-            if (cb) {
-                // getter with cb
-                getter = function getter() {
-                    return source.call(instance);
-                };
-            } else {
-                // no cb -> simple effect
-                getter = function getter() {
-                    if (instance && instance.isUnmounted) {
-                        return;
-                    }
-
-                    if (cleanup) {
-                        cleanup();
-                    }
-
-                    return source.call(instance, onInvalidate);
-                };
-            }
-        } else {
-            getter = function getter() {};
+    if (_.isArray(result)) {
+      return result.concat();
+    }
 
-            warnInvalidSource(source);
-        }
+    return result;
+  }
 
-        if (cb && deep) {
-            var baseGetter = getter;
+  function watch(model, expOrFn, cb, options) {
+    if (isPlainObject(cb)) {
+      options = cb;
+      cb = cb.handler;
+    }
 
-            getter = function getter() {
-                return traverse(baseGetter());
-            };
-        }
+    if (typeof cb === "string") {
+      cb = model[cb];
+    }
 
-        var cleanup;
+    options = options || {};
+    options.user = true;
+    var exps;
 
-        var onInvalidate = function onInvalidate(fn) {
-            cleanup = runner.options.onStop = function () {
-                fn.call(instance);
-            };
-        };
+    if (_.isFunction(expOrFn)) {
+      var watcher = innerWatch(expOrFn, cb, options);
+      return function unwatchFn() {
+        watcher();
+      };
+    }
 
-        var oldValue = _.isArray(source) ? [] : INITIAL_WATCHER_VALUE;
+    if (!(exps = expOrFn.match(/[a-zA-Z0-9_.*]+|[|][|]|[&][&]|[(]|[)]/g)) || exps.length === 1 && !/\*/.test(expOrFn)) {
+      var paths = expOrFn.split(".");
+      var prePaths = paths.slice(0, paths.length - 1);
+      var preGetter = parsePath(prePaths.join("."));
+      var v = preGetter.call(model, model);
+      var getter = parsePath(paths[paths.length - 1]);
 
-        var job = function job() {
-            if (!runner.active) {
-                return;
-            }
+      var _watcher = innerWatch(function () {
+        return watchExp(v, getter);
+      }, cb, options);
 
-            if (cb) {
-                // watch(source, cb)
-                var newValue = runner();
+      return function unwatchFn() {
+        _watcher();
+      };
+    }
 
-                if (deep || forceTrigger || hasChanged(newValue, oldValue)) {
-                    // cleanup before running cb again
-                    if (cleanup) {
-                        cleanup();
-                    }
+    var watchers = [];
+    var fns = exps.slice();
+    var complete = false,
+        running = false;
 
-                    cb.apply(instance, [newValue, // pass undefined as the old value when it's changed for the first time
-                        oldValue === INITIAL_WATCHER_VALUE ? undefined : oldValue, onInvalidate]);
-                    oldValue = newValue;
-                }
-            } else {
-                // watchEffect
-                runner();
-            }
-        }; // important: mark the job as a watcher callback so that scheduler knows
-        // it is allowed to self-trigger (#1727)
+    var callback = function callback(index, newValue, oldValue, attrs) {
+      if (complete === true) {
+        return;
+      }
 
+      fns[index] = true;
 
-        job.allowRecurse = !!cb;
-        job.id = ++uid;
-        var scheduler;
+      if (runBinaryFunction(fns)) {
+        complete = true;
+        cb(newValue, oldValue, attrs);
+      }
 
-        if (sync === true) {
-            scheduler = job;
-        } else {
-            scheduler = function scheduler() {
-                return queueWatcher(job);
-            };
+      if (options && options.sync) {
+        complete = false;
+        running = false;
+        fns = exps.slice();
+      } else {
+        if (!running) {
+          running = true;
+          nextTick(function () {
+            complete = false;
+            running = false;
+            fns = exps.slice();
+          });
         }
+      }
+    };
 
-        var runner = effect(getter, {
-            lazy: true,
-            onTrack: onTrack,
-            onTrigger: onTrigger,
-            scheduler: scheduler
-        }); // initial run
-
-        if (cb) {
-            if (immediate) {
-                job();
+    _.each(exps, function (exp, i) {
+      if (_.has(operators, exp)) {
+        return;
+      }
+
+      if (exp.indexOf("*") >= 0) {
+        // eslint-disable-next-line no-inner-declarations
+        var travers = function travers(root, deps, parent, key, res) {
+          if (deps.length === _paths.length) {
+            root !== undefined && res.push({
+              parent: parent,
+              k: key
+            });
+            return;
+          }
+
+          if (root) {
+            if (_paths[deps.length] === "*") {
+              // 遍历所有节点
+              for (var k in root) {
+                travers(root[k], deps.concat([k]), root, k, res);
+              }
             } else {
-                oldValue = runner();
+              var nextKey = _paths[deps.length];
+              travers(root[nextKey], deps.concat([nextKey]), root, nextKey, res);
             }
-        } else {
-            runner();
-        }
-
-        return function () {
-            stop(runner);
+          }
         };
-    }
-
-    function traverse(value) {
-        var seen = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Set();
 
-        if (!_.isObject(value) || seen.has(value)) {
-            return value;
-        }
+        //a.**形式
+        if (/^[1-9a-zA-Z.]+\*\*$/.test(exp) || exp === "**") {
+          exp = exp.replace(".**", "");
 
-        seen.add(value);
+          var _paths2 = exp.split(".");
 
-        if (isRef(value)) {
-            traverse(value.value, seen);
-        } else if (_.isArray(value)) {
-            for (var i = 0; i < value.length; i++) {
-                traverse(value[i], seen);
-            }
-        } else if (isSet(value) || isMap(value)) {
-            value.forEach(function (v) {
-                traverse(v, seen);
-            });
-        } else {
-            for (var key in value) {
-                traverse(value[key], seen);
-            }
-        }
+          var _prePaths2 = _paths2.slice(0, _paths2.length - 1);
 
-        return value;
-    }
+          var _preGetter = parsePath(_prePaths2.join("."));
 
-    var falsy;
-    var operators = {
-        "||": falsy,
-        "&&": falsy,
-        "(": falsy,
-        ")": falsy
-    };
+          var _v2 = _preGetter.call(model, model);
 
-    function runBinaryFunction(binarys) {
-        var expr = "";
+          var _getter = exp === "**" ? function (m) {
+            return m;
+          } : parsePath(_paths2[_paths2.length - 1]);
 
-        for (var i = 0, len = binarys.length; i < len; i++) {
-            if (_.isBoolean(binarys[i]) || _.has(operators, binarys[i])) {
-                expr += binarys[i];
-            } else {
-                expr += "false";
-            }
+          watchers.push(innerWatch(function () {
+            return watchExp(_v2, _getter);
+          }, function (newValue, oldValue) {
+            callback(i, newValue, oldValue, _.extend({
+              index: i
+            }));
+          }, _.extend({
+            deep: true
+          }, options)));
+          return;
         }
 
-        return new Function("return " + expr)();
-    }
+        if (/^(\*\*\.)+[1-9a-zA-Z]+(\.\*\*$)/.test(exp)) {
+          throw new Error("not support");
+        } //含有*的情况，如a.*,如*.a,*.*.a,a.*.a
+        //先获取到能获取到的对象
 
-    function watchExp(model, exp) {
-        var getter = parsePath(exp);
-        var result = getter.call(model, model);
 
-        if (_.isArray(result)) {
-            return result.concat();
-        }
+        var _paths = exp.split(".");
 
-        return result;
-    }
+        var _prePaths = [];
 
-    function watch(model, expOrFn, cb, options) {
-        if (isPlainObject(cb)) {
-            options = cb;
-            cb = cb.handler;
-        }
+        for (var _i = 0, len = _paths.length; _i < len; _i++) {
+          if (_paths[_i] === "*") {
+            break;
+          }
 
-        if (typeof cb === "string") {
-            cb = model[cb];
+          _prePaths[_i] = _paths[_i];
         }
 
-        options = options || {};
-        options.user = true;
-        var exps;
+        var _v;
 
-        if (_.isFunction(expOrFn) || !(exps = expOrFn.match(/[a-zA-Z0-9_.*]+|[|][|]|[&][&]|[(]|[)]/g)) || exps.length === 1 && !/\*/.test(expOrFn)) {
-            var watcher = innerWatch(_.isFunction(expOrFn) ? expOrFn : function () {
-                return watchExp(model, expOrFn);
-            }, cb, options);
-            return function unwatchFn() {
-                watcher();
-            };
-        }
+        if (_prePaths.length > 0) {
+          var _getter2 = parsePath(_prePaths.join("."));
 
-        var watchers = [];
-        var fns = exps.slice();
-        var complete = false,
-            running = false;
+          _v = _getter2.call(model, model);
+        } else {
+          _v = model;
+        }
 
-        var callback = function callback(index, newValue, oldValue, attrs) {
-            if (complete === true) {
-                return;
-            }
+        _paths = _paths.slice(_prePaths.length);
+        var changes = [];
+        watchers.push(innerWatch(function () {
+          var routes = [];
+          travers(_v, [], _v, null, routes);
 
-            fns[index] = true;
+          for (var _i2 = 0, _len = routes.length; _i2 < _len; _i2++) {
+            var _routes$_i = routes[_i2],
+                parent = _routes$_i.parent,
+                k = _routes$_i.k;
 
-            if (runBinaryFunction(fns)) {
-                complete = true;
-                cb(newValue, oldValue, attrs);
-            }
+            for (var j = 0, l = changes.length; j < l; j++) {
+              var _changes$j = changes[j],
+                  target = _changes$j.target,
+                  key = _changes$j.key;
 
-            if (options && options.sync) {
-                complete = false;
-                running = false;
-                fns = exps.slice();
-            } else {
-                if (!running) {
-                    running = true;
-                    nextTick(function () {
-                        complete = false;
-                        running = false;
-                        fns = exps.slice();
-                    });
-                }
-            }
-        };
-
-        _.each(exps, function (exp, i) {
-            if (_.has(operators, exp)) {
-                return;
-            } //a.**形式
-
-
-            if (/^[1-9a-zA-Z.]+\*\*$/.test(exp) || exp === "**") {
-                exp = exp.replace(".**", "");
-                var getter = exp === "**" ? function (m) {
-                    return m;
-                } : parsePath(exp);
-                var v = getter.call(model, model);
-                watchers.push(innerWatch(v, function (newValue, oldValue) {
-                    callback(i, newValue, oldValue, _.extend({
-                        index: i
-                    }));
-                }));
-                return;
-            }
-
-            if (/^(\*\*\.)+[1-9a-zA-Z]+(\.\*\*$)/.test(exp)) {
-                throw new Error("not support");
-            } //含有*的情况，如a.*,如*.a,*.*.a,a.*.a
-
-
-            if (/\*/.test(exp)) {
-                // eslint-disable-next-line no-inner-declarations
-                var travers = function travers(root, deps, parent, key, res) {
-                    if (deps.length === paths.length) {
-                        root !== undefined && res.push({
-                            parent: parent,
-                            k: key
-                        });
-                        return;
-                    }
-
-                    if (root) {
-                        if (paths[deps.length] === "*") {
-                            // 遍历所有节点
-                            for (var k in root) {
-                                travers(root[k], deps.concat([k]), root, k, res);
-                            }
-                        } else {
-                            var nextKey = paths[deps.length];
-                            travers(root[nextKey], deps.concat([nextKey]), root, nextKey, res);
-                        }
-                    }
-                };
-
-                //先获取到能获取到的对象
-                var paths = exp.split(".");
-                var prePaths = [];
-
-                for (var _i = 0, len = paths.length; _i < len; _i++) {
-                    if (paths[_i] === "*") {
-                        break;
-                    }
-
-                    prePaths[_i] = paths[_i];
-                }
-
-                var _v;
-
-                if (prePaths.length > 0) {
-                    var _getter = parsePath(prePaths.join("."));
-
-                    _v = _getter.call(model, model);
-                } else {
-                    _v = model;
-                }
-
-                paths = paths.slice(prePaths.length);
-                var changes = [];
-                watchers.push(innerWatch(function () {
-                    var routes = [];
-                    travers(_v, [], _v, null, routes);
-
-                    for (var _i2 = 0, _len = routes.length; _i2 < _len; _i2++) {
-                        var _routes$_i = routes[_i2],
-                            parent = _routes$_i.parent,
-                            k = _routes$_i.k;
-
-                        for (var j = 0, l = changes.length; j < l; j++) {
-                            var _changes$j = changes[j],
-                                target = _changes$j.target,
-                                key = _changes$j.key;
-
-                            if (target === toRaw(parent) && key === k) {
-                                return true;
-                            }
-                        }
-                    }
-                }, function (newValue) {
-                    changes = [];
-
-                    if (newValue === true) {
-                        callback(i, undefined, undefined, _.extend({
-                            index: i
-                        }));
-                    }
-                }, {
-                    deep: true,
-                    onTrigger: function onTrigger(_ref) {
-                        var target = _ref.target,
-                            key = _ref.key;
-                        changes.push({
-                            target: target,
-                            key: key
-                        });
-                    }
-                }));
-                return;
+              if (target === toRaw(parent) && key === k) {
+                return true;
+              }
             }
+          }
+        }, function (newValue) {
+          changes = [];
 
-            watchers.push(innerWatch(function () {
-                return watchExp(model, exp);
-            }, function (newValue, oldValue) {
-                callback(i, newValue, oldValue, _.extend({
-                    index: i
-                }));
+          if (newValue === true) {
+            callback(i, undefined, undefined, _.extend({
+              index: i
             }));
-        });
+          }
+        }, BI.extend({}, options, {
+          deep: true,
+          onTrigger: function onTrigger(_ref) {
+            var target = _ref.target,
+                key = _ref.key;
+            changes.push({
+              target: target,
+              key: key
+            });
+          }
+        })));
+        return;
+      }
+
+      var getter = parsePath(exp);
+      watchers.push(innerWatch(function () {
+        return watchExp(model, getter);
+      }, function (newValue, oldValue) {
+        callback(i, newValue, oldValue, _.extend({
+          index: i
+        }));
+      }, options));
+    });
 
-        return watchers;
-    }
+    return watchers;
+  }
 
-    var REACTIVE = true;
+  var REACTIVE = true;
 
-    function initState(vm, state) {
-        if (state) {
-            vm.$$state = REACTIVE ? reactive(state) : state;
-        }
+  function initState(vm, state) {
+    if (state) {
+      vm.$$state = REACTIVE ? reactive(state) : state;
     }
+  }
 
-    function initComputed(vm, c) {
-        var $$computed = vm.$$computed = {};
+  function initComputed(vm, c) {
+    var $$computed = vm.$$computed = {};
 
-        for (var key in c) {
-            $$computed[key] = computed(_.bind(c[key], vm));
-        }
+    for (var key in c) {
+      $$computed[key] = computed(_.bind(c[key], vm));
     }
+  }
 
-    function initWatch(vm, watch) {
-        vm._watchers || (vm._watchers = []);
+  function initWatch(vm, watch) {
+    vm._watchers || (vm._watchers = []);
 
-        for (var key in watch) {
-            var handler = watch[key];
+    for (var key in watch) {
+      var handler = watch[key];
 
-            if (_.isArray(handler)) {
-                for (var i = 0; i < handler.length; i++) {
-                    vm._watchers.push(createWatcher(vm, key, handler[i]));
-                }
-            } else {
-                vm._watchers.push(createWatcher(vm, key, handler));
-            }
+      if (_.isArray(handler)) {
+        for (var i = 0; i < handler.length; i++) {
+          vm._watchers.push(createWatcher(vm, key, handler[i]));
         }
+      } else {
+        vm._watchers.push(createWatcher(vm, key, handler));
+      }
     }
+  }
 
-    function createWatcher(vm, keyOrFn, cb, options) {
-        if (isPlainObject(cb)) {
-            options = cb;
-            cb = cb.handler;
-        }
-
-        if (typeof cb === "string") {
-            cb = vm[cb];
-        }
-
-        return watch(vm.model, keyOrFn, _.bind(cb, vm), options);
+  function createWatcher(vm, keyOrFn, cb, options) {
+    if (isPlainObject(cb)) {
+      options = cb;
+      cb = cb.handler;
     }
 
-    function initMethods(vm, methods) {
-        for (var key in methods) {
-            vm[key] = methods[key] == null ? noop : _.bind(methods[key], vm);
-        }
+    if (typeof cb === "string") {
+      cb = vm[cb];
     }
 
-    function initMixins(vm, mixins) {
-        mixins = (mixins || []).slice(0);
+    return watch(vm.model, keyOrFn, _.bind(cb, vm), options);
+  }
 
-        _.each(mixins.reverse(), function (mixinType) {
-            var mixin = getMixins(mixinType);
-
-            for (var key in mixin) {
-                if (typeof mixin[key] !== "function") continue;
-                if (_.has(vm, key)) continue;
-                vm[key] = _.bind(mixin[key], vm);
-            }
-        });
+  function initMethods(vm, methods) {
+    for (var key in methods) {
+      vm[key] = methods[key] == null ? noop : _.bind(methods[key], vm);
     }
+  }
 
-    function defineProps(vm) {
-        vm.model = new Proxy({}, {
-            get: function get(target, key) {
-                if (vm.$$computed && key in vm.$$computed) {
-                    try {
-                        return vm.$$computed[key].value;
-                    } catch (e) {// 吞掉异常
-                    }
-
-                    return;
-                }
+  function initMixins(vm, mixins) {
+    mixins = (mixins || []).slice(0);
 
-                if (vm.$$state && key in vm.$$state) {
-                    return vm.$$state[key];
-                }
+    _.each(mixins.reverse(), function (mixinType) {
+      var mixin = getMixins(mixinType);
 
-                var p = vm._parent;
-
-                while (p) {
-                    if (p.$$context && key in p.$$context) {
-                        return p.$$context[key];
-                    }
-
-                    p = p._parent;
-                }
-            },
-            set: function set(target, key, value) {
-                if (vm.$$state && key in vm.$$state) {
-                    vm.$$state[key] = value;
-                    return true;
-                }
+      for (var key in mixin) {
+        if (typeof mixin[key] !== "function") continue;
+        if (_.has(vm, key)) continue;
+        vm[key] = _.bind(mixin[key], vm);
+      }
+    });
+  }
 
-                var p = vm._parent;
+  function defineProps(vm) {
+    vm.model = new Proxy({}, {
+      get: function get(target, key) {
+        if (vm.$$computed && key in vm.$$computed) {
+          try {
+            return vm.$$computed[key].value;
+          } catch (e) {// 吞掉异常
+          }
 
-                while (p) {
-                    if (p.$$context && key in p.$$context) {
-                        p.$$context[key] = value;
-                        return true;
-                    }
+          return;
+        }
 
-                    p = p._parent;
-                }
+        if (vm.$$state && key in vm.$$state) {
+          return vm.$$state[key];
+        }
 
-                return true;
-            }
-        });
-    }
+        var p = vm._parent;
 
-    function defineContext(vm, keys) {
-        var props = {};
-
-        var _loop = function _loop(i, len) {
-            var key = keys[i];
-            props[key] = {
-                enumerable: true,
-                configurable: true,
-                get: function get() {
-                    return vm.model[key];
-                },
-                set: function set(val) {
-                    return vm.model[key] = val;
-                }
-            };
-        };
+        while (p) {
+          if (p.$$context && key in p.$$context) {
+            return p.$$context[key];
+          }
 
-        for (var i = 0, len = keys.length; i < len; i++) {
-            _loop(i);
+          p = p._parent;
+        }
+      },
+      set: function set(target, key, value) {
+        if (vm.$$state && key in vm.$$state) {
+          vm.$$state[key] = value;
+          return true;
         }
 
-        vm.$$context = Object.defineProperties({}, props);
-    }
-
-    function getInjectValue(vm, key) {
         var p = vm._parent;
 
         while (p) {
-            if (p.$$context && key in p.$$context) {
-                return p.$$context[key];
-            }
+          if (p.$$context && key in p.$$context) {
+            p.$$context[key] = value;
+            return true;
+          }
+
+          p = p._parent;
+        }
 
-            p = p._parent;
+        return true;
+      }
+    });
+  }
+
+  function defineContext(vm, keys) {
+    var props = {};
+
+    var _loop = function _loop(i, len) {
+      var key = keys[i];
+      props[key] = {
+        enumerable: true,
+        configurable: true,
+        get: function get() {
+          return vm.model[key];
+        },
+        set: function set(val) {
+          return vm.model[key] = val;
         }
+      };
+    };
+
+    for (var i = 0, len = keys.length; i < len; i++) {
+      _loop(i);
     }
 
-    function getInjectValues(vm) {
-        var inject = vm.inject || [];
-        var result = {};
+    vm.$$context = Object.defineProperties({}, props);
+  }
 
-        _.each(inject, function (key) {
-            result[key] = getInjectValue(vm, key);
-        });
+  function getInjectValue(vm, key) {
+    var p = vm._parent;
+
+    while (p) {
+      if (p.$$context && key in p.$$context) {
+        return p.$$context[key];
+      }
 
-        return result;
+      p = p._parent;
     }
+  }
 
-    var Model = /*#__PURE__*/function () {
-        function Model() {
-            _classCallCheck(this, Model);
-        }
+  function getInjectValues(vm) {
+    var inject = vm.inject || [];
+    var result = {};
 
-        _createClass(Model, [{
-            key: "_constructor",
-            value: function _constructor(options, destroyHandler) {
-                this.options = options || {};
-                this._parent = Model.target;
-                var state = _.isFunction(this.state) ? this.state() : this.state;
-                var computed = this.computed;
-                var context = this.context;
-                var inject = this.inject;
-                var childContext = this.childContext;
-                var watch = this.watch;
-                var actions = this.actions;
-
-                _.keys(state).concat(_.keys(computed)).concat(inject || []).concat(context || []);
-
-                var mixins = this.mixins;
-                defineProps(this);
-                childContext && defineContext(this, childContext);
-                initMixins(this, mixins);
-                this.init();
-                initState(this, _.extend(getInjectValues(this), state));
-                initComputed(this, computed);
-                REACTIVE && initWatch(this, watch);
-                initMethods(this, actions);
-                this.created && this.created();
-                this._destroyHandler = destroyHandler;
-            }
-        }, {
-            key: "_init",
-            value: function _init() {}
-        }, {
-            key: "init",
-            value: function init() {
-                this._init();
-            }
-        }, {
-            key: "destroy",
-            value: function destroy() {
-                _.each(this._watchers, function (unwatches) {
-                    unwatches = _.isArray(unwatches) ? unwatches : [unwatches];
-
-                    _.each(unwatches, function (unwatch) {
-                        unwatch();
-                    });
-                });
-
-                this._watchers && (this._watchers = []);
-                this.destroyed && this.destroyed();
-                this.$$computed = null;
-                this.$$state = null;
-                this._destroyHandler && this._destroyHandler();
-            }
-        }]);
-
-        return Model;
-    }();
-    function set(target, key, val) {
-        if (_.isArray(target)) {
-            target.length = Math.max(target.length, key);
-            target.splice(key, 1, val);
-            return val;
-        }
+    _.each(inject, function (key) {
+      result[key] = getInjectValue(vm, key);
+    });
 
-        target[key] = val;
-    }
-    function del(target, key) {
-        if (_.isArray(target)) {
-            target.splice(key, 1);
-            return;
-        }
+    return result;
+  }
+
+  var Model = /*#__PURE__*/function () {
+    function Model() {
+      _classCallCheck(this, Model);
+    }
+
+    _createClass(Model, [{
+      key: "_constructor",
+      value: function _constructor(options, destroyHandler) {
+        this.options = options || {};
+        this._parent = Model.target;
+        var state = _.isFunction(this.state) ? this.state() : this.state;
+        var computed = this.computed;
+        var context = this.context;
+        var inject = this.inject;
+        var childContext = this.childContext;
+        var watch = this.watch;
+        var actions = this.actions;
+
+        _.keys(state).concat(_.keys(computed)).concat(inject || []).concat(context || []);
+
+        var mixins = this.mixins;
+        defineProps(this);
+        childContext && defineContext(this, childContext);
+        initMixins(this, mixins);
+        this.init();
+        initState(this, _.extend(getInjectValues(this), state));
+        initComputed(this, computed);
+        REACTIVE && initWatch(this, watch);
+        initMethods(this, actions);
+        this.created && this.created();
+        this._destroyHandler = destroyHandler;
+      }
+    }, {
+      key: "_init",
+      value: function _init() {}
+    }, {
+      key: "init",
+      value: function init() {
+        this._init();
+      }
+    }, {
+      key: "destroy",
+      value: function destroy() {
+        _.each(this._watchers, function (unwatches) {
+          unwatches = _.isArray(unwatches) ? unwatches : [unwatches];
+
+          _.each(unwatches, function (unwatch) {
+            unwatch();
+          });
+        });
 
-        if (!_.has(target, key)) {
-            return;
-        }
+        this._watchers && (this._watchers = []);
+        this.destroyed && this.destroyed();
+        this.$$computed = null;
+        this.$$state = null;
+        this._destroyHandler && this._destroyHandler();
+      }
+    }]);
 
-        delete target[key];
+    return Model;
+  }();
+  function set(target, key, val) {
+    if (_.isArray(target)) {
+      target.length = Math.max(target.length, key);
+      target.splice(key, 1, val);
+      return val;
     }
-    function define(model) {
-        return REACTIVE ? reactive(model) : model;
+
+    target[key] = val;
+  }
+  function del(target, key) {
+    if (_.isArray(target)) {
+      target.splice(key, 1);
+      return;
     }
-    function config(options) {
-        options || (options = {});
 
-        if ("reactive" in options) {
-            REACTIVE = options.reactive;
-        }
+    if (!_.has(target, key)) {
+      return;
     }
 
-    function toJSON(model) {
-        var result;
+    delete target[key];
+  }
+  function define(model) {
+    return REACTIVE ? reactive(model) : model;
+  }
+  function config(options) {
+    options || (options = {});
+
+    if ("reactive" in options) {
+      REACTIVE = options.reactive;
+    }
+  }
 
-        if (_.isArray(model)) {
-            result = [];
+  function toJSON(model) {
+    var result;
 
-            for (var i = 0, len = model.length; i < len; i++) {
-                result[i] = toJSON(model[i]);
-            }
-        } else if (model && isPlainObject(model)) {
-            result = {};
+    if (_.isArray(model)) {
+      result = [];
 
-            for (var key in model) {
-                result[key] = toJSON(model[key]);
-            }
-        } else {
-            result = model;
-        }
+      for (var i = 0, len = model.length; i < len; i++) {
+        result[i] = toJSON(model[i]);
+      }
+    } else if (model && isPlainObject(model)) {
+      result = {};
 
-        return result;
+      for (var key in model) {
+        result[key] = toJSON(model[key]);
+      }
+    } else {
+      result = model;
     }
 
-    var version = "3.0";
+    return result;
+  }
+
+  var version = "3.0";
 
-    exports.Model = Model;
-    exports.config = config;
-    exports.define = define;
-    exports.del = del;
-    exports.mixin = mixin;
-    exports.set = set;
-    exports.toJSON = toJSON;
-    exports.version = version;
-    exports.watch = watch;
+  exports.Model = Model;
+  exports.config = config;
+  exports.define = define;
+  exports.del = del;
+  exports.mixin = mixin;
+  exports.set = set;
+  exports.toJSON = toJSON;
+  exports.version = version;
+  exports.watch = watch;
 
-    Object.defineProperty(exports, '__esModule', { value: true });
+  Object.defineProperty(exports, '__esModule', { value: true });
 
 })));
diff --git a/src/less/lib/background.less b/src/less/lib/background.less
index 1f291a5fe..a331a88da 100644
--- a/src/less/lib/background.less
+++ b/src/less/lib/background.less
@@ -8,7 +8,3 @@
 @background-trans-color-disabled: "background/trans_disable.png";
 @background-auto-color-square-normal: "icon/auto_square_normal.png";
 @background-auto-color-no-square-normal: "icon/auto_no_square_normal.png";
-
-@background-farbtastic-wheel:"background/wheel.png";
-@background-farbtastic-overlay:"background/mask.png";
-@background-farbtastic-marker:"background/marker.png";