(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 = {}));
}(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;
            };
        } 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;
    }

    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);
    };

    var isArray = Array.isArray;

    var isMap$1 = function isMap(val) {
        return toTypeString$1(val) === "[object Map]";
    };

    var isFunction = function isFunction(val) {
        return typeof val === "function";
    };

    var isString = function isString(val) {
        return typeof val === "string";
    };

    var isSymbol = function isSymbol(val) {
        return _typeof(val) === "symbol";
    };

    var isObject = function isObject(val) {
        return val !== null && _typeof(val) === "object";
    };

    var objectToString$1 = Object.prototype.toString;

    var toTypeString$1 = function toTypeString(value) {
        return objectToString$1.call(value);
    };

    var toRawType = function toRawType(value) {
        return (// extract "RawType" from strings like "[object RawType]"
            toTypeString$1(value).slice(8, -1)
        );
    };

    var isIntegerKey = function isIntegerKey(key) {
        return isString(key) && key !== "NaN" && key[0] !== "-" && "".concat(parseInt(key, 10)) === key;
    };

    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 capitalize = cacheStringFunction(function (str) {
        return str.charAt(0).toUpperCase() + str.slice(1);
    }); // compare whether a value has changed, accounting for NaN.

    var hasChanged$1 = function hasChanged(value, oldValue) {
        return value !== oldValue && (value === value || oldValue === oldValue);
    };

    var targetMap = new WeakMap();
    var effectStack = [];
    var activeEffect;
    var ITERATE_KEY = Symbol("iterate");
    var MAP_KEY_ITERATE_KEY = Symbol("Map key iterate");

    function isEffect(fn) {
        return fn && fn._isEffect === true;
    }

    function effect(fn) {
        var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : EMPTY_OBJ;

        if (isEffect(fn)) {
            fn = fn.raw;
        }

        var effect = createReactiveEffect(fn, options);

        if (!options.lazy) {
            effect();
        }

        return effect;
    }

    function stop(effect) {
        if (effect.active) {
            cleanup(effect);

            if (effect.options.onStop) {
                effect.options.onStop();
            }

            effect.active = false;
        }
    }

    var uid$1 = 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];
                }
            }
        };

        effect.id = uid$1++;
        effect.allowRecurse = !!options.allowRecurse;
        effect._isEffect = true;
        effect.active = true;
        effect.raw = fn;
        effect.deps = [];
        effect.options = options;
        return effect;
    }

    function cleanup(effect) {
        var deps = effect.deps;

        if (deps.length) {
            for (var i = 0; i < deps.length; i++) {
                deps[i].delete(effect);
            }

            deps.length = 0;
        }
    }

    var shouldTrack = true;
    var trackStack = [];

    function pauseTracking() {
        trackStack.push(shouldTrack);
        shouldTrack = false;
    }

    function enableTracking() {
        trackStack.push(shouldTrack);
        shouldTrack = true;
    }

    function resetTracking() {
        var last = trackStack.pop();
        shouldTrack = last === undefined ? true : last;
    }

    function track(target, type, key) {
        if (!shouldTrack || activeEffect === undefined) {
            return;
        }

        var depsMap = targetMap.get(target);

        if (!depsMap) {
            targetMap.set(target, depsMap = new Map());
        }

        var dep = depsMap.get(key);

        if (!dep) {
            depsMap.set(key, dep = new Set());
        }

        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
                });
            }
        }
    }

    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;
            }
        }

        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 (effect.options.scheduler) {
                effect.options.scheduler(effect);
            } else {
                effect();
            }
        };

        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];
            }

            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);
            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;
            }

            var targetIsArray = isArray(target);

            if (targetIsArray && hasOwn(arrayInstrumentations, key)) {
                return Reflect.get(arrayInstrumentations, key, receiver);
            }

            var res = Reflect.get(target, key, receiver);

            if (isSymbol(key) ? builtInSymbols.has(key) : key === "__proto__" || key === "__v_isRef") {
                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();
    var shallowSet = /* #__PURE__*/createSetter(true);

    function createSetter() {
        var shallow = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
        return function set(target, key, value, receiver) {
            var oldValue = target[key];

            if (!shallow) {
                value = toRaw(value);

                if (!isArray(target) && isRef(oldValue) && !isRef(value)) {
                    oldValue.value = value;
                    return true;
                }
            }

            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);
                }
            }

            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;
        }
    };
    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 toReadonly = function toReadonly(value) {
        return isObject(value) ? readonly(value) : value;
    };

    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 = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;

        if (has.call(rawTarget, key)) {
            return wrap(target.get(key));
        } else if (has.call(rawTarget, rawKey)) {
            return wrap(target.get(rawKey));
        }
    }

    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);
        var result = target.add(value);

        if (!hadKey) {
            trigger(target, "add"
                /* ADD */
                , value, value);
        }

        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;

        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);
        var result = target.set(key, value);

        if (!hadKey) {
            trigger(target, "add"
                /* ADD */
                , key, value);
        } else if (hasChanged$1(value, oldValue) || key === "length") {
            trigger(target, "set"
                /* SET */
                , key, value, oldValue);
        }

        return result;
    }

    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;
    }

    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)
                );
            });
        };
    }

    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;
        };
    }

    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)
    };
    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)
    };
    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);
    });

    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)
    };
    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 reactiveMap = new WeakMap();
    var readonlyMap = new WeakMap();

    function targetTypeMap(rawType) {
        switch (rawType) {
            case "Object":
            case "Array":
                return 1;

            case "Map":
            case "Set":
            case "WeakMap":
            case "WeakSet":
                return 2;

            default:
                return 0;
        }
    }

    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);
    } // 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.


        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) {
        return observed && toRaw(observed["__v_raw"
            /* RAW */
            ]) || observed;
    }

    function isRef(r) {
        return Boolean(r && r.__v_isRef === true);
    }

    var ComputedRefImpl = /*#__PURE__*/function () {
        function ComputedRefImpl(getter, _setter, isReadonly) {
            var _this2 = this;

            _classCallCheck(this, ComputedRefImpl);

            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;
        }

        _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);
            }
        }]);

        return ComputedRefImpl;
    }();

    function computed(getterOrOptions) {
        var getter;
        var setter;

        if (isFunction(getterOrOptions)) {
            getter = getterOrOptions;

            setter = function setter() {
                console.warn("Write operation failed: computed value is readonly");
            };
        } else {
            getter = getterOrOptions.get;
            setter = getterOrOptions.set;
        }

        return new ComputedRefImpl(getter, setter, isFunction(getterOrOptions) || !getterOrOptions.set);
    }

    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]";
    }
    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 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


            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;

                while (i > index && queue[i].watcher.id > watcher.id) {
                    i--;
                }

                queue.splice(i + 1, 0, {
                    watcher: watcher,
                    options: options
                });
            } // queue the flush


            if (!waiting) {
                waiting = true;
                nextTick(flushSchedulerQueue);
            }
        }
    }

    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.");
        }

        return doWatch(source, cb, options);
    }
    var INITIAL_WATCHER_VALUE = {};
    var objectToString = Object.prototype.toString;

    var toTypeString = function toTypeString(value) {
        return objectToString.call(value);
    };

    var isMap = function isMap(val) {
        return toTypeString(val) === "[object Map]";
    };

    var isSet = function isSet(val) {
        return toTypeString(val) === "[object Set]";
    };

    var hasChanged = function hasChanged(value, oldValue) {
        return value !== oldValue && (value === value || oldValue === oldValue);
    };

    var uid = 0;

    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 (!cb) {
            if (immediate !== undefined) {
                console.warn("watch() \"immediate\" option is only respected when using the " + "watch(source, callback, options?) signature.");
            }

            if (deep !== undefined) {
                console.warn("watch() \"deep\" option is only respected when using the " + "watch(source, callback, options?) signature.");
            }
        }

        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 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);
                };
            } 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() {};

            warnInvalidSource(source);
        }

        if (cb && deep) {
            var baseGetter = getter;

            getter = function getter() {
                return traverse(baseGetter());
            };
        }

        var cleanup;

        var onInvalidate = function onInvalidate(fn) {
            cleanup = runner.options.onStop = function () {
                fn.call(instance);
            };
        };

        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(getter, {
            lazy: true,
            onTrack: onTrack,
            onTrigger: onTrigger,
            scheduler: scheduler
        }); // initial run

        if (cb) {
            if (immediate) {
                job();
            } else {
                oldValue = runner();
            }
        } 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;
        }

        seen.add(value);

        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);
            }
        }

        return value;
    }

    var falsy;
    var operators = {
        "||": falsy,
        "&&": falsy,
        "(": falsy,
        ")": falsy
    };

    function runBinaryFunction(binarys) {
        var expr = "";

        for (var i = 0, len = binarys.length; i < len; i++) {
            if (_.isBoolean(binarys[i]) || _.has(operators, binarys[i])) {
                expr += binarys[i];
            } else {
                expr += "false";
            }
        }

        return new Function("return " + expr)();
    }

    function watchExp(model, exp) {
        var getter = parsePath(exp);
        var result = getter.call(model, model);

        if (_.isArray(result)) {
            return result.concat();
        }

        return result;
    }

    function watch(model, expOrFn, cb, options) {
        if (isPlainObject(cb)) {
            options = cb;
            cb = cb.handler;
        }

        if (typeof cb === "string") {
            cb = model[cb];
        }

        options = options || {};
        options.user = true;
        var exps;

        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();
            };
        }

        var watchers = [];
        var fns = exps.slice();
        var complete = false,
            running = false;

        var callback = function callback(index, newValue, oldValue, attrs) {
            if (complete === true) {
                return;
            }

            fns[index] = true;

            if (runBinaryFunction(fns)) {
                complete = true;
                cb(newValue, oldValue, attrs);
            }

            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;
            }

            watchers.push(innerWatch(function () {
                return watchExp(model, exp);
            }, function (newValue, oldValue) {
                callback(i, newValue, oldValue, _.extend({
                    index: i
                }));
            }));
        });

        return watchers;
    }

    var REACTIVE = true;

    function initState(vm, state) {
        if (state) {
            vm.$$state = REACTIVE ? reactive(state) : state;
        }
    }

    function initComputed(vm, c) {
        var $$computed = vm.$$computed = {};

        for (var key in c) {
            $$computed[key] = computed(_.bind(c[key], vm));
        }
    }

    function initWatch(vm, watch) {
        vm._watchers || (vm._watchers = []);

        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));
            }
        }
    }

    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 initMethods(vm, methods) {
        for (var key in methods) {
            vm[key] = methods[key] == null ? noop : _.bind(methods[key], vm);
        }
    }

    function initMixins(vm, mixins) {
        mixins = (mixins || []).slice(0);

        _.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 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;
                }

                if (vm.$$state && key in vm.$$state) {
                    return vm.$$state[key];
                }

                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;
                }

                var p = vm._parent;

                while (p) {
                    if (p.$$context && key in p.$$context) {
                        p.$$context[key] = value;
                        return true;
                    }

                    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);
        }

        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];
            }

            p = p._parent;
        }
    }

    function getInjectValues(vm) {
        var inject = vm.inject || [];
        var result = {};

        _.each(inject, function (key) {
            result[key] = getInjectValue(vm, key);
        });

        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();
                    });
                });

                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;
        }

        target[key] = val;
    }
    function del(target, key) {
        if (_.isArray(target)) {
            target.splice(key, 1);
            return;
        }

        if (!_.has(target, key)) {
            return;
        }

        delete target[key];
    }
    function define(model) {
        return REACTIVE ? reactive(model) : model;
    }
    function config(options) {
        options || (options = {});

        if ("reactive" in options) {
            REACTIVE = options.reactive;
        }
    }

    function toJSON(model) {
        var result;

        if (_.isArray(model)) {
            result = [];

            for (var i = 0, len = model.length; i < len; i++) {
                result[i] = toJSON(model[i]);
            }
        } else if (model && isPlainObject(model)) {
            result = {};

            for (var key in model) {
                result[key] = toJSON(model[key]);
            }
        } else {
            result = model;
        }

        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;

    Object.defineProperty(exports, '__esModule', { value: true });

})));