as-model 0.2.3 → 0.2.5

package/dist/index.js

@@ -1,801 +1,828 @@
 "use strict";
-(() => {
-  // node_modules/@swc/helpers/esm/_define_property.js
-  function _define_property(obj, key, value) {
-    if (key in obj) {
-      Object.defineProperty(obj, key, {
-        value,
-        enumerable: true,
-        configurable: true,
-        writable: true
-      });
-    } else obj[key] = value;
-    return obj;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-  // node_modules/@swc/helpers/esm/_object_spread.js
-  function _object_spread(target) {
-    for (var i = 1; i < arguments.length; i++) {
-      var source = arguments[i] != null ? arguments[i] : {};
-      var ownKeys2 = Object.keys(source);
-      if (typeof Object.getOwnPropertySymbols === "function") {
-        ownKeys2 = ownKeys2.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
-          return Object.getOwnPropertyDescriptor(source, sym).enumerable;
-        }));
-      }
-      ownKeys2.forEach(function(key) {
-        _define_property(target, key, source[key]);
-      });
-    }
-    return target;
-  }
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  config: () => config,
+  createKey: () => createKey2,
+  createSelector: () => createSelector,
+  createSignal: () => createSignal,
+  createStore: () => createStore2,
+  createStores: () => createStores2,
+  model: () => model,
+  shallowEqual: () => shallowEqual,
+  validations: () => validations
+});
+module.exports = __toCommonJS(index_exports);
 
-  // node_modules/@swc/helpers/esm/_object_spread_props.js
-  function ownKeys(object, enumerableOnly) {
-    var keys = Object.keys(object);
-    if (Object.getOwnPropertySymbols) {
-      var symbols = Object.getOwnPropertySymbols(object);
-      if (enumerableOnly) {
-        symbols = symbols.filter(function(sym) {
-          return Object.getOwnPropertyDescriptor(object, sym).enumerable;
-        });
-      }
-      keys.push.apply(keys, symbols);
+// node_modules/@swc/helpers/esm/_define_property.js
+function _define_property(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else obj[key] = value;
+  return obj;
+}
+
+// node_modules/@swc/helpers/esm/_object_spread.js
+function _object_spread(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i] != null ? arguments[i] : {};
+    var ownKeys2 = Object.keys(source);
+    if (typeof Object.getOwnPropertySymbols === "function") {
+      ownKeys2 = ownKeys2.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+        return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+      }));
     }
-    return keys;
+    ownKeys2.forEach(function(key) {
+      _define_property(target, key, source[key]);
+    });
   }
-  function _object_spread_props(target, source) {
-    source = source != null ? source : {};
-    if (Object.getOwnPropertyDescriptors) Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
-    else {
-      ownKeys(Object(source)).forEach(function(key) {
-        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+  return target;
+}
+
+// node_modules/@swc/helpers/esm/_object_spread_props.js
+function ownKeys(object, enumerableOnly) {
+  var keys = Object.keys(object);
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+    if (enumerableOnly) {
+      symbols = symbols.filter(function(sym) {
+        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
       });
     }
-    return target;
+    keys.push.apply(keys, symbols);
+  }
+  return keys;
+}
+function _object_spread_props(target, source) {
+  source = source != null ? source : {};
+  if (Object.getOwnPropertyDescriptors) Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+  else {
+    ownKeys(Object(source)).forEach(function(key) {
+      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+    });
   }
+  return target;
+}
 
-  // node_modules/@swc/helpers/esm/_object_without_properties_loose.js
-  function _object_without_properties_loose(source, excluded) {
-    if (source == null) return {};
-    var target = {};
-    var sourceKeys = Object.keys(source);
-    var key, i;
-    for (i = 0; i < sourceKeys.length; i++) {
-      key = sourceKeys[i];
-      if (excluded.indexOf(key) >= 0) continue;
-      target[key] = source[key];
-    }
-    return target;
+// node_modules/@swc/helpers/esm/_object_without_properties_loose.js
+function _object_without_properties_loose(source, excluded) {
+  if (source == null) return {};
+  var target = {};
+  var sourceKeys = Object.keys(source);
+  var key, i;
+  for (i = 0; i < sourceKeys.length; i++) {
+    key = sourceKeys[i];
+    if (excluded.indexOf(key) >= 0) continue;
+    target[key] = source[key];
   }
+  return target;
+}
 
-  // node_modules/@swc/helpers/esm/_object_without_properties.js
-  function _object_without_properties(source, excluded) {
-    if (source == null) return {};
-    var target = _object_without_properties_loose(source, excluded);
-    var key, i;
-    if (Object.getOwnPropertySymbols) {
-      var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
-      for (i = 0; i < sourceSymbolKeys.length; i++) {
-        key = sourceSymbolKeys[i];
-        if (excluded.indexOf(key) >= 0) continue;
-        if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
-        target[key] = source[key];
-      }
+// node_modules/@swc/helpers/esm/_object_without_properties.js
+function _object_without_properties(source, excluded) {
+  if (source == null) return {};
+  var target = _object_without_properties_loose(source, excluded);
+  var key, i;
+  if (Object.getOwnPropertySymbols) {
+    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+    for (i = 0; i < sourceSymbolKeys.length; i++) {
+      key = sourceSymbolKeys[i];
+      if (excluded.indexOf(key) >= 0) continue;
+      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+      target[key] = source[key];
     }
-    return target;
   }
+  return target;
+}
 
-  // node_modules/@swc/helpers/esm/_array_like_to_array.js
-  function _array_like_to_array(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;
-  }
+// node_modules/@swc/helpers/esm/_array_like_to_array.js
+function _array_like_to_array(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;
+}
 
-  // node_modules/@swc/helpers/esm/_array_without_holes.js
-  function _array_without_holes(arr) {
-    if (Array.isArray(arr)) return _array_like_to_array(arr);
-  }
+// node_modules/@swc/helpers/esm/_array_without_holes.js
+function _array_without_holes(arr) {
+  if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
 
-  // node_modules/@swc/helpers/esm/_iterable_to_array.js
-  function _iterable_to_array(iter) {
-    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) {
-      return Array.from(iter);
-    }
+// node_modules/@swc/helpers/esm/_iterable_to_array.js
+function _iterable_to_array(iter) {
+  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) {
+    return Array.from(iter);
   }
+}
 
-  // node_modules/@swc/helpers/esm/_non_iterable_spread.js
-  function _non_iterable_spread() {
-    throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-  }
+// node_modules/@swc/helpers/esm/_non_iterable_spread.js
+function _non_iterable_spread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
 
-  // node_modules/@swc/helpers/esm/_unsupported_iterable_to_array.js
-  function _unsupported_iterable_to_array(o, minLen) {
-    if (!o) return;
-    if (typeof o === "string") return _array_like_to_array(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(n);
-    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
-  }
+// node_modules/@swc/helpers/esm/_unsupported_iterable_to_array.js
+function _unsupported_iterable_to_array(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _array_like_to_array(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(n);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
 
-  // node_modules/@swc/helpers/esm/_to_consumable_array.js
-  function _to_consumable_array(arr) {
-    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
-  }
+// node_modules/@swc/helpers/esm/_to_consumable_array.js
+function _to_consumable_array(arr) {
+  return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
 
-  // node_modules/@swc/helpers/esm/_type_of.js
-  function _type_of(obj) {
-    "@swc/helpers - typeof";
-    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
-  }
+// node_modules/@swc/helpers/esm/_type_of.js
+function _type_of(obj) {
+  "@swc/helpers - typeof";
+  return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
 
-  // src/identifiers/index.ts
-  function modelKeyIdentifier() {
-    return true;
-  }
-  function modelUsageIdentifier() {
-    return true;
-  }
-  function modelStoreIdentifier() {
-    return true;
-  }
-  function tokenIdentifier() {
-    return true;
-  }
+// src/identifiers/index.ts
+function modelKeyIdentifier() {
+  return true;
+}
+function modelUsageIdentifier() {
+  return true;
+}
+function modelStoreIdentifier() {
+  return true;
+}
+function tokenIdentifier() {
+  return true;
+}
 
-  // src/validation/index.ts
-  var noStateAModelKey = "no-state-a-model-key";
-  function createNoStateModel() {
-    return function noStateModel(state) {
-      return _define_property({}, noStateAModelKey, true);
-    };
+// src/validation/index.ts
+var noStateAModelKey = "no-state-a-model-key";
+function createNoStateModel() {
+  return function noStateModel(state) {
+    return _define_property({}, noStateAModelKey, true);
+  };
+}
+function isInstanceFromNoStateModel(instance) {
+  if (instance == null) {
+    return false;
   }
-  function isInstanceFromNoStateModel(instance) {
-    if (instance == null) {
-      return false;
-    }
-    if ((typeof instance === "undefined" ? "undefined" : _type_of(instance)) !== "object") {
-      return false;
-    }
-    var ins = instance;
-    return !!ins[noStateAModelKey];
+  if ((typeof instance === "undefined" ? "undefined" : _type_of(instance)) !== "object") {
+    return false;
   }
-  function isModelKey(data) {
-    if (!data) {
-      return false;
-    }
-    return data.modelKeyIdentifier === modelKeyIdentifier && data.modelKeyIdentifier();
+  var ins = instance;
+  return !!ins[noStateAModelKey];
+}
+function isModelKey(data) {
+  if (!data) {
+    return false;
   }
-  function isModelUsage(data) {
-    if (!data) {
-      return false;
-    }
-    return data.modelUsageIdentifier === modelUsageIdentifier && data.modelUsageIdentifier();
+  return data.modelKeyIdentifier === modelKeyIdentifier && data.modelKeyIdentifier();
+}
+function isModelUsage(data) {
+  if (!data) {
+    return false;
   }
-  function isModelStore(data) {
-    if (!data) {
-      return false;
-    }
-    return data.modelStoreIdentifier === modelStoreIdentifier && data.modelStoreIdentifier();
+  return data.modelUsageIdentifier === modelUsageIdentifier && data.modelUsageIdentifier();
+}
+function isModelStore(data) {
+  if (!data) {
+    return false;
   }
-  function isToken(data) {
-    if (!data) {
-      return false;
-    }
-    return data.tokenIdentifier === tokenIdentifier && data.tokenIdentifier();
+  return data.modelStoreIdentifier === modelStoreIdentifier && data.modelStoreIdentifier();
+}
+function isToken(data) {
+  if (!data) {
+    return false;
   }
-  function isStoreIndex(data) {
-    if (!data) {
-      return false;
-    }
-    return !!data.key && isModelKey(data.key);
+  return data.tokenIdentifier === tokenIdentifier && data.tokenIdentifier();
+}
+function isStoreIndex(data) {
+  if (!data) {
+    return false;
   }
-  var validations = {
-    isInstanceFromNoStateModel,
-    isModelKey,
-    isModelStore,
-    isModelUsage,
-    isToken,
-    isStoreIndex
-  };
+  return !!data.key && isModelKey(data.key);
+}
+var validations = {
+  isInstanceFromNoStateModel,
+  isModelKey,
+  isModelStore,
+  isModelUsage,
+  isToken,
+  isStoreIndex
+};
 
-  // src/tools/proxy.ts
-  function getDescriptors(target, receiver, ownOrPrototype, handler) {
-    var it = Object.keys(ownOrPrototype);
-    var result = {};
-    it.forEach(function(key) {
-      result[key] = {
-        get: function() {
-          if (!handler.get) {
-            return target[key];
-          }
-          return handler.get(target, key, receiver);
-        },
-        set: function(v) {
-          if (!handler.set) {
-            target[key] = v;
-            return;
-          }
-          var valid = handler.set(target, key, v, receiver);
-          if (!valid) {
-            throw new Error("".concat(key, " in proxy target is not mutable"));
-          }
+// src/tools/proxy.ts
+function getDescriptors(target, receiver, ownOrPrototype, handler) {
+  var it = Object.keys(ownOrPrototype);
+  var result = {};
+  it.forEach(function(key) {
+    result[key] = {
+      get: function() {
+        if (!handler.get) {
+          return target[key];
         }
-      };
-    });
-    return result;
+        return handler.get(target, key, receiver);
+      },
+      set: function(v) {
+        if (!handler.set) {
+          target[key] = v;
+          return;
+        }
+        var valid = handler.set(target, key, v, receiver);
+        if (!valid) {
+          throw new Error("".concat(key, " in proxy target is not mutable"));
+        }
+      }
+    };
+  });
+  return result;
+}
+var createSimpleProxy = function(target, handler) {
+  var proxy = {};
+  var own = getDescriptors(target, proxy, target, handler);
+  var prototype = getDescriptors(target, proxy, Object.getPrototypeOf(target), handler);
+  Object.defineProperties(proxy, _object_spread({}, prototype, own));
+  return proxy;
+};
+var createProxy = function(target, handler) {
+  if (typeof Proxy !== "function") {
+    return createSimpleProxy(target, handler);
   }
-  var createSimpleProxy = function(target, handler) {
-    var proxy = {};
-    var own = getDescriptors(target, proxy, target, handler);
-    var prototype = getDescriptors(target, proxy, Object.getPrototypeOf(target), handler);
-    Object.defineProperties(proxy, _object_spread({}, prototype, own));
-    return proxy;
-  };
-  var createProxy = function(target, handler) {
-    if (typeof Proxy !== "function") {
-      return createSimpleProxy(target, handler);
-    }
-    return new Proxy(target, handler);
-  };
+  return new Proxy(target, handler);
+};
 
-  // src/tools/shallowEqual.ts
-  function isObject(data) {
-    return data && (typeof data === "undefined" ? "undefined" : _type_of(data)) === "object";
+// src/tools/shallowEqual.ts
+function isObject(data) {
+  return data && (typeof data === "undefined" ? "undefined" : _type_of(data)) === "object";
+}
+function shallowEqual(prev, current) {
+  if (Object.is(prev, current)) {
+    return true;
   }
-  function shallowEqual(prev, current) {
-    if (Object.is(prev, current)) {
-      return true;
-    }
-    if (!isObject(prev) || !isObject(current)) {
-      return false;
-    }
-    var prevKeys = Object.keys(prev);
-    var currentKeys = Object.keys(current);
-    if (prevKeys.length !== currentKeys.length) {
-      return false;
-    }
-    var pre = prev;
-    var curr = current;
-    var hasDiffKey = prevKeys.some(function(key) {
-      return !Object.prototype.hasOwnProperty.call(curr, key);
-    });
-    if (hasDiffKey) {
-      return false;
-    }
-    var hasDiffValue = currentKeys.some(function(key) {
-      var currentValue = curr[key];
-      var prevValue = pre[key];
-      return !Object.is(currentValue, prevValue);
-    });
-    return !hasDiffValue;
+  if (!isObject(prev) || !isObject(current)) {
+    return false;
   }
-
-  // src/tools/index.ts
-  function noop() {
+  var prevKeys = Object.keys(prev);
+  var currentKeys = Object.keys(current);
+  if (prevKeys.length !== currentKeys.length) {
+    return false;
   }
-  function simpleErrorProcess(errors) {
-    return function wrap(callback) {
-      return function replaced() {
-        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-          args[_key] = arguments[_key];
-        }
-        try {
-          return callback.apply(void 0, _to_consumable_array(args));
-        } catch (e) {
-          errors.push(e);
-        }
-      };
-    };
+  var pre = prev;
+  var curr = current;
+  var hasDiffKey = prevKeys.some(function(key) {
+    return !Object.prototype.hasOwnProperty.call(curr, key);
+  });
+  if (hasDiffKey) {
+    return false;
   }
+  var hasDiffValue = currentKeys.some(function(key) {
+    var currentValue = curr[key];
+    var prevValue = pre[key];
+    return !Object.is(currentValue, prevValue);
+  });
+  return !hasDiffValue;
+}
 
-  // src/updater/token.ts
-  function createToken() {
-    var value = {};
-    return {
-      isDifferent: function isDifferent(token) {
-        if (!isToken(token)) {
-          return true;
-        }
-        return token.value !== value;
-      },
-      value
+// src/tools/index.ts
+function noop() {
+}
+function simpleErrorProcess(errors) {
+  return function wrap(callback) {
+    return function replaced() {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      try {
+        return callback.apply(void 0, _to_consumable_array(args));
+      } catch (e) {
+        errors.push(e);
+      }
     };
-  }
+  };
+}
 
-  // src/updater/notifier.ts
-  function defaultNotifyImplement(dispatches, action) {
-    dispatches.forEach(function(callback) {
-      callback(action);
-    });
-  }
-  function generateNotifier(updater, middleWare) {
-    function pendAction(value) {
-      updater.mutate(function(u) {
-        var dispatching = u.dispatching;
-        if (!dispatching) {
-          var wrap = {
-            value
-          };
-          wrap.tail = wrap;
-          return _object_spread_props(_object_spread({}, u), {
-            dispatching: wrap
-          });
-        }
-        var tail = dispatching.tail;
-        if (!tail) {
-          return u;
-        }
-        var current = {
-          prev: tail,
+// src/updater/token.ts
+function createToken() {
+  var value = {};
+  return {
+    isDifferent: function isDifferent(token) {
+      if (!isToken(token)) {
+        return true;
+      }
+      return token.value !== value;
+    },
+    value
+  };
+}
+
+// src/updater/notifier.ts
+function defaultNotifyImplement(dispatches, action) {
+  dispatches.forEach(function(callback) {
+    callback(action);
+  });
+}
+function generateNotifier(updater, middleWare) {
+  function pendAction(value) {
+    updater.mutate(function(u) {
+      var dispatching = u.dispatching;
+      if (!dispatching) {
+        var wrap = {
           value
         };
-        tail.next = current;
-        dispatching.tail = current;
+        wrap.tail = wrap;
         return _object_spread_props(_object_spread({}, u), {
-          dispatching
+          dispatching: wrap
         });
+      }
+      var tail = dispatching.tail;
+      if (!tail) {
+        return u;
+      }
+      var current = {
+        prev: tail,
+        value
+      };
+      tail.next = current;
+      dispatching.tail = current;
+      return _object_spread_props(_object_spread({}, u), {
+        dispatching
       });
-    }
-    function unshiftAction() {
-      return updater.mutate(function(u) {
-        var dispatching = updater.dispatching;
-        if (!dispatching) {
-          return u;
-        }
-        var next = dispatching.next, tail = dispatching.tail;
-        if (tail === dispatching || !next) {
-          dispatching.tail = void 0;
-          return _object_spread_props(_object_spread({}, u), {
-            dispatching: void 0
-          });
-        }
-        next.prev = void 0;
-        var newFirst = next;
-        newFirst.tail = tail;
+    });
+  }
+  function unshiftAction() {
+    return updater.mutate(function(u) {
+      var dispatching = updater.dispatching;
+      if (!dispatching) {
+        return u;
+      }
+      var next = dispatching.next, tail = dispatching.tail;
+      if (tail === dispatching || !next) {
+        dispatching.tail = void 0;
         return _object_spread_props(_object_spread({}, u), {
-          dispatching: newFirst
+          dispatching: void 0
         });
-      }).dispatching;
-    }
-    function consumeTemporaries() {
-      var temporaryDispatches = updater.temporaryDispatches;
-      updater.mutate(function(u) {
-        return u.temporaryDispatches.length ? _object_spread_props(_object_spread({}, u), {
-          dispatches: _to_consumable_array(u.dispatches).concat(_to_consumable_array(u.temporaryDispatches)),
-          temporaryDispatches: []
-        }) : u;
+      }
+      next.prev = void 0;
+      var newFirst = next;
+      newFirst.tail = tail;
+      return _object_spread_props(_object_spread({}, u), {
+        dispatching: newFirst
       });
-      var initializedAction = {
-        state: updater.state,
-        prevState: updater.state,
-        instance: updater.instance,
-        prevInstance: updater.instance,
-        type: null,
-        method: null
-      };
-      temporaryDispatches.forEach(function(d) {
-        if (!d.accessible) {
-          return;
-        }
-        d.dispatch(initializedAction);
+    }).dispatching;
+  }
+  function consumeTemporaries() {
+    var temporaryDispatches = updater.temporaryDispatches;
+    updater.mutate(function(u) {
+      return u.temporaryDispatches.length ? _object_spread_props(_object_spread({}, u), {
+        dispatches: _to_consumable_array(u.dispatches).concat(_to_consumable_array(u.temporaryDispatches)),
+        temporaryDispatches: []
+      }) : u;
+    });
+    var initializedAction = {
+      state: updater.state,
+      prevState: updater.state,
+      instance: updater.instance,
+      prevInstance: updater.instance,
+      type: null,
+      method: null
+    };
+    temporaryDispatches.forEach(function(d) {
+      if (!d.accessible) {
+        return;
+      }
+      d.dispatch(initializedAction);
+    });
+  }
+  var dispatch = function dispatch2(action) {
+    var dispatches = updater.dispatches, controlled = updater.controlled, model2 = updater.model, config2 = updater.config;
+    var state = action.state;
+    var nextInstance = model2(state);
+    var nextAction = _object_spread_props(_object_spread({}, action), {
+      instance: nextInstance
+    });
+    if (!controlled) {
+      updater.mutate(function(u) {
+        return _object_spread_props(_object_spread({}, u), {
+          state,
+          instance: nextInstance,
+          version: u.version + 1,
+          token: createToken()
+        });
       });
     }
-    var dispatch = function dispatch2(action) {
-      var dispatches = updater.dispatches, controlled = updater.controlled, model2 = updater.model, config2 = updater.config;
-      var state = action.state;
-      var nextInstance = model2(state);
-      var nextAction = _object_spread_props(_object_spread({}, action), {
-        instance: nextInstance
-      });
-      if (!controlled) {
-        updater.mutate(function(u) {
-          return _object_spread_props(_object_spread({}, u), {
-            state,
-            instance: nextInstance,
-            version: u.version + 1,
-            token: createToken()
-          });
-        });
-      }
-      var notifyAction = function notifyAction2(act) {
-        var errors = [];
-        var dispatchWrap = simpleErrorProcess(errors);
-        var dispatchCallbacks = dispatches.map(function(d) {
-          return dispatchWrap(function dispatchCallback(ac) {
-            if (!d.accessible) {
-              return;
-            }
-            d.dispatch(ac);
-          });
+    var notifyAction = function notifyAction2(act) {
+      var errors = [];
+      var dispatchWrap = simpleErrorProcess(errors);
+      var dispatchCallbacks = dispatches.map(function(d) {
+        return dispatchWrap(function dispatchCallback(ac) {
+          if (!d.accessible) {
+            return;
+          }
+          d.dispatch(ac);
         });
-        defaultNotifyImplement(dispatchCallbacks, act);
-        if (!errors.length) {
-          return {
-            errors: void 0
-          };
-        }
+      });
+      defaultNotifyImplement(dispatchCallbacks, act);
+      if (!errors.length) {
         return {
-          errors
+          errors: void 0
         };
+      }
+      return {
+        errors
       };
-      var notifyActionWithErrorThrow = function notifyActionWithErrorThrow2(act) {
-        var errors = notifyAction(act).errors;
-        if (!errors || !errors.length) {
-          return;
-        }
-        throw errors[0];
-      };
-      try {
-        if (typeof config2.notify === "function") {
-          config2.notify(notifyAction, nextAction);
-        } else {
-          notifyActionWithErrorThrow(nextAction);
-        }
-      } catch (e) {
+    };
+    var notifyActionWithErrorThrow = function notifyActionWithErrorThrow2(act) {
+      var errors = notifyAction(act).errors;
+      if (!errors || !errors.length) {
+        return;
+      }
+      throw errors[0];
+    };
+    try {
+      if (typeof config2.notify === "function") {
+        config2.notify(notifyAction, nextAction);
+      } else {
+        notifyActionWithErrorThrow(nextAction);
+      }
+    } catch (e) {
+      updater.mutate(function(u) {
+        return _object_spread_props(_object_spread({}, u), {
+          dispatching: void 0
+        });
+      });
+      throw e;
+    }
+  };
+  return function notify(action) {
+    if (action == null || updater.isDestroyed) {
+      return;
+    }
+    var dispatching = updater.dispatching;
+    pendAction(action);
+    if (dispatching) {
+      return;
+    }
+    while (updater.dispatching) {
+      var wrap = updater.dispatching;
+      if (wrap) {
+        middleWare({
+          getState: function getState() {
+            return {
+              state: updater.state,
+              instance: updater.instance
+            };
+          },
+          dispatch: notify
+        })(dispatch)(wrap.value);
+        unshiftAction();
+      } else {
         updater.mutate(function(u) {
           return _object_spread_props(_object_spread({}, u), {
             dispatching: void 0
           });
         });
-        throw e;
       }
-    };
-    return function notify(action) {
-      if (action == null || updater.isDestroyed) {
-        return;
-      }
-      var dispatching = updater.dispatching;
-      pendAction(action);
-      if (dispatching) {
-        return;
+    }
+    consumeTemporaries();
+  };
+}
+
+// src/updater/tunnel.ts
+function createUnInitializedUpdater() {
+  return {
+    notify: function(a) {
+    },
+    createTunnel: function(dispatcher) {
+      return {
+        connect: noop,
+        disconnect: noop
+      };
+    }
+  };
+}
+function destroy(updater) {
+  function destroyDispatching() {
+    updater.mutate(function(u) {
+      var dispatching = u.dispatching;
+      if (!dispatching) {
+        return u;
       }
-      while (updater.dispatching) {
-        var wrap = updater.dispatching;
-        if (wrap) {
-          middleWare({
-            getState: function getState() {
-              return {
-                state: updater.state,
-                instance: updater.instance
-              };
-            },
-            dispatch: notify
-          })(dispatch)(wrap.value);
-          unshiftAction();
-        } else {
-          updater.mutate(function(u) {
-            return _object_spread_props(_object_spread({}, u), {
-              dispatching: void 0
-            });
-          });
+      var wrapper = dispatching;
+      while (wrapper) {
+        var next = wrapper.next;
+        wrapper.next = void 0;
+        wrapper.prev = void 0;
+        if (next) {
+          next.prev = void 0;
         }
+        wrapper = next;
       }
-      consumeTemporaries();
-    };
+      dispatching.tail = void 0;
+      return _object_spread_props(_object_spread({}, u), {
+        dispatching: void 0,
+        initialized: false
+      });
+    });
   }
-
-  // src/updater/tunnel.ts
-  function createUnInitializedUpdater() {
-    return {
-      notify: function(a) {
-      },
-      createTunnel: function(dispatcher) {
-        return {
-          connect: noop,
-          disconnect: noop
-        };
-      }
+  updater.mutate(function(u, effect) {
+    var destroyed = createUnInitializedUpdater();
+    effect(function() {
+      destroyDispatching();
+    });
+    return _object_spread_props(_object_spread({}, u, destroyed), {
+      sidePayload: void 0,
+      isDestroyed: true
+    });
+  });
+}
+function generateTunnelCreator(updater) {
+  function subscribe(dispatchFn) {
+    var dispatches = updater.dispatches, temporaryDispatches = updater.temporaryDispatches, isControlled = updater.controlled;
+    var copied = _to_consumable_array(dispatches).concat(_to_consumable_array(temporaryDispatches));
+    var exist = copied.some(function(d) {
+      return d.dispatch === dispatchFn;
+    });
+    if (exist) {
+      return updater.mutate(function(u) {
+        return _object_spread_props(_object_spread({}, u), {
+          isDestroyed: false
+        });
+      });
+    }
+    var dispatcher = {
+      dispatch: dispatchFn,
+      accessible: true
     };
-  }
-  function destroy(updater) {
-    function destroyDispatching() {
-      updater.mutate(function(u) {
-        var dispatching = u.dispatching;
-        if (!dispatching) {
-          return u;
-        }
-        var wrapper = dispatching;
-        while (wrapper) {
-          var next = wrapper.next;
-          wrapper.next = void 0;
-          wrapper.prev = void 0;
-          if (next) {
-            next.prev = void 0;
-          }
-          wrapper = next;
-        }
-        dispatching.tail = void 0;
+    if (isControlled) {
+      return updater.mutate(function(u) {
         return _object_spread_props(_object_spread({}, u), {
-          dispatching: void 0,
-          initialized: false
+          dispatches: [
+            dispatcher
+          ],
+          isDestroyed: false
         });
       });
     }
-    updater.mutate(function(u, effect) {
-      var destroyed = createUnInitializedUpdater();
-      effect(function() {
-        destroyDispatching();
+    return updater.mutate(function(u, effect) {
+      var tds = u.temporaryDispatches, ds = u.dispatches;
+      var nextTds = _to_consumable_array(tds).concat([
+        dispatcher
+      ]);
+      if (u.dispatching) {
+        return _object_spread_props(_object_spread({}, u), {
+          temporaryDispatches: nextTds,
+          isDestroyed: false
+        });
+      }
+      effect(function(up) {
+        var initializedAction = {
+          state: up.state,
+          prevState: up.state,
+          instance: up.instance,
+          prevInstance: up.instance,
+          type: null,
+          method: null
+        };
+        nextTds.forEach(function(td) {
+          td.dispatch(initializedAction);
+        });
       });
-      return _object_spread_props(_object_spread({}, u, destroyed), {
-        sidePayload: void 0,
-        isDestroyed: true
+      return _object_spread_props(_object_spread({}, u), {
+        temporaryDispatches: [],
+        dispatches: _to_consumable_array(ds).concat(_to_consumable_array(nextTds)),
+        isDestroyed: false
       });
     });
   }
-  function generateTunnelCreator(updater) {
-    function subscribe(dispatchFn) {
-      var dispatches = updater.dispatches, temporaryDispatches = updater.temporaryDispatches, isControlled = updater.controlled;
-      var copied = _to_consumable_array(dispatches).concat(_to_consumable_array(temporaryDispatches));
-      var exist = copied.some(function(d) {
-        return d.dispatch === dispatchFn;
-      });
-      if (exist) {
-        return updater.mutate(function(u) {
-          return _object_spread_props(_object_spread({}, u), {
-            isDestroyed: false
-          });
-        });
-      }
-      var dispatcher = {
-        dispatch: dispatchFn,
-        accessible: true
-      };
-      if (isControlled) {
-        return updater.mutate(function(u) {
-          return _object_spread_props(_object_spread({}, u), {
-            dispatches: [
-              dispatcher
-            ],
-            isDestroyed: false
-          });
+  return function tunnel(dispatchFn) {
+    function disconnect() {
+      updater.mutate(function(u) {
+        var ds = u.dispatches, tds = u.temporaryDispatches;
+        var found = _to_consumable_array(ds).concat(_to_consumable_array(tds)).find(function(d) {
+          return d.dispatch === dispatchFn;
         });
-      }
-      return updater.mutate(function(u, effect) {
-        var tds = u.temporaryDispatches, ds = u.dispatches;
-        var nextTds = _to_consumable_array(tds).concat([
-          dispatcher
-        ]);
-        if (u.dispatching) {
-          return _object_spread_props(_object_spread({}, u), {
-            temporaryDispatches: nextTds,
-            isDestroyed: false
-          });
+        if (!found) {
+          return u;
         }
-        effect(function(up) {
-          var initializedAction = {
-            state: up.state,
-            prevState: up.state,
-            instance: up.instance,
-            prevInstance: up.instance,
-            type: null,
-            method: null
-          };
-          nextTds.forEach(function(td) {
-            td.dispatch(initializedAction);
-          });
+        found.accessible = false;
+        var nextDs = ds.filter(function(d) {
+          return d !== found;
+        });
+        var nextTds = tds.filter(function(d) {
+          return d !== found;
         });
         return _object_spread_props(_object_spread({}, u), {
-          temporaryDispatches: [],
-          dispatches: _to_consumable_array(ds).concat(_to_consumable_array(nextTds)),
-          isDestroyed: false
+          dispatches: nextDs,
+          temporaryDispatches: nextTds
         });
       });
     }
-    return function tunnel(dispatchFn) {
-      function disconnect() {
-        updater.mutate(function(u) {
-          var ds = u.dispatches, tds = u.temporaryDispatches;
-          var found = _to_consumable_array(ds).concat(_to_consumable_array(tds)).find(function(d) {
-            return d.dispatch === dispatchFn;
-          });
-          if (!found) {
-            return u;
-          }
-          found.accessible = false;
-          var nextDs = ds.filter(function(d) {
-            return d !== found;
-          });
-          var nextTds = tds.filter(function(d) {
-            return d !== found;
-          });
-          return _object_spread_props(_object_spread({}, u), {
-            dispatches: nextDs,
-            temporaryDispatches: nextTds
-          });
-        });
+    return {
+      connect: function connect() {
+        subscribe(dispatchFn);
+      },
+      disconnect: function disconnect1() {
+        disconnect();
       }
-      return {
-        connect: function connect() {
-          subscribe(dispatchFn);
-        },
-        disconnect: function disconnect1() {
-          disconnect();
-        }
-      };
     };
-  }
+  };
+}
 
-  // src/updater/index.ts
-  function createInitializedUpdater(updater, middleWare) {
-    var createTunnel = generateTunnelCreator(updater);
-    return {
-      notify: generateNotifier(updater, middleWare),
-      createTunnel
-    };
-  }
-  function createUpdateFn(updater, middleWare) {
-    return function update() {
-      var args = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
-      updater.mutate(function(u, effect) {
-        var _args_model;
-        var model2 = (_args_model = args.model) !== null && _args_model !== void 0 ? _args_model : u.model;
-        var hasState = Object.prototype.hasOwnProperty.call(args, "state");
-        var hasInitialState = Object.prototype.hasOwnProperty.call(args, "initialState");
-        var state = hasState ? args.state : u.state;
-        var isInitialize = !u.initialized || hasInitialState;
-        var token = createToken();
-        if (u.controlled) {
-          var controlledState = hasInitialState && !hasState ? args.initialState : state;
-          var instance = model2(controlledState);
-          return _object_spread_props(_object_spread({}, u), {
-            state: controlledState,
-            instance,
-            model: model2
-          });
-        }
-        if (u.isDestroyed) {
-          return u;
-        }
-        if (!u.initialized && !hasState && !hasInitialState) {
-          throw new Error("The updater has not been initialized, it should be updated with a state for initializing.");
-        }
-        if (isInitialize) {
-          var initialState = hasInitialState ? args.initialState : state;
-          var instance1 = model2(initialState);
-          var initializedUpdater = createInitializedUpdater(u, middleWare);
-          return _object_spread(_object_spread_props(_object_spread({}, u), {
-            model: model2,
-            state: initialState,
-            instance: instance1,
-            initialized: true,
-            token
-          }), initializedUpdater);
-        }
-        if (Object.is(u.model, model2) && Object.is(u.state, state)) {
-          return u;
-        }
-        effect(function(up) {
-          up.notify({
-            type: null,
-            method: null,
-            prevInstance: u.instance,
-            instance: u.instance,
-            prevState: u.state,
-            state
-          });
-        });
+// src/updater/index.ts
+function createInitializedUpdater(updater, middleWare) {
+  var createTunnel = generateTunnelCreator(updater);
+  return {
+    notify: generateNotifier(updater, middleWare),
+    createTunnel
+  };
+}
+function createUpdateFn(updater, middleWare) {
+  return function update() {
+    var args = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+    updater.mutate(function(u, effect) {
+      var _args_model;
+      var model2 = (_args_model = args.model) !== null && _args_model !== void 0 ? _args_model : u.model;
+      var hasState = Object.prototype.hasOwnProperty.call(args, "state");
+      var hasInitialState = Object.prototype.hasOwnProperty.call(args, "initialState");
+      var state = hasState ? args.state : u.state;
+      var isInitialize = !u.initialized || hasInitialState;
+      var token = createToken();
+      if (u.controlled) {
+        var controlledState = hasInitialState && !hasState ? args.initialState : state;
+        var instance = model2(controlledState);
         return _object_spread_props(_object_spread({}, u), {
+          state: controlledState,
+          instance,
+          model: model2
+        });
+      }
+      if (u.isDestroyed) {
+        return u;
+      }
+      if (!u.initialized && !hasState && !hasInitialState) {
+        throw new Error("The updater has not been initialized, it should be updated with a state for initializing.");
+      }
+      if (isInitialize) {
+        var initialState = hasInitialState ? args.initialState : state;
+        var instance1 = model2(initialState);
+        var initializedUpdater = createInitializedUpdater(u, middleWare);
+        return _object_spread(_object_spread_props(_object_spread({}, u), {
           model: model2,
+          state: initialState,
+          instance: instance1,
           initialized: true,
-          cacheFields: {},
-          cacheMethods: {}
+          token
+        }), initializedUpdater);
+      }
+      if (Object.is(u.model, model2) && Object.is(u.state, state)) {
+        return u;
+      }
+      effect(function(up) {
+        up.notify({
+          type: null,
+          method: null,
+          prevInstance: u.instance,
+          instance: u.instance,
+          prevState: u.state,
+          state
         });
       });
-    };
-  }
-  var lazyModel = createNoStateModel();
-  function createUpdater(model2, middleWare) {
-    var config2 = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
-    var hasDefaultState = "state" in config2;
-    var controlled = config2.controlled, defaultState = config2.state;
-    var defaultInstance = hasDefaultState ? model2(defaultState) : lazyModel(void 0);
-    var unInitializedUpdater = createUnInitializedUpdater();
-    var updater = _object_spread({
-      sidePayload: void 0,
-      version: 0,
-      token: createToken(),
-      isDestroyed: false,
-      model: model2,
-      instance: defaultInstance,
-      dispatch: null,
-      dispatches: [],
-      temporaryDispatches: [],
-      cacheMethods: {},
-      cacheFields: {},
-      state: defaultState,
-      initialized: hasDefaultState,
-      controlled: !!controlled,
-      isSubscribing: false,
-      config: config2,
-      payload: function payload(setter) {
-        if (typeof setter === "function") {
-          updater.sidePayload = setter(updater.sidePayload);
-        }
-        return updater.sidePayload;
-      },
-      mutate: function mutate(callback) {
-        var effects = [];
-        var runEffects = function runEffects2(u) {
-          effects.forEach(function(e) {
-            return e(u);
-          });
-        };
-        var result = callback(updater, function(effectFn) {
-          return effects.push(effectFn);
-        });
-        if (updater === result) {
-          runEffects(result);
-          return updater;
-        }
-        Object.assign(updater, result);
-        runEffects(updater);
-        return updater;
-      },
-      update: function(args) {
-      },
-      destroy: function destroy1() {
-        destroy(updater);
-      }
-    }, unInitializedUpdater);
-    var initialized = createInitializedUpdater(updater, middleWare);
-    Object.assign(updater, initialized, {
-      update: createUpdateFn(updater, middleWare)
+      return _object_spread_props(_object_spread({}, u), {
+        model: model2,
+        initialized: true,
+        cacheFields: {},
+        cacheMethods: {}
+      });
     });
-    return updater;
-  }
-
-  // src/store/cache.ts
-  var cacheIdentify = {
-    field: function field(d) {
-      if (!d) {
-        return false;
+  };
+}
+var lazyModel = createNoStateModel();
+function createUpdater(model2, middleWare) {
+  var config2 = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+  var hasDefaultState = "state" in config2;
+  var controlled = config2.controlled, defaultState = config2.state;
+  var defaultInstance = hasDefaultState ? model2(defaultState) : lazyModel(void 0);
+  var unInitializedUpdater = createUnInitializedUpdater();
+  var updater = _object_spread({
+    sidePayload: void 0,
+    version: 0,
+    token: createToken(),
+    isDestroyed: false,
+    model: model2,
+    instance: defaultInstance,
+    dispatch: null,
+    dispatches: [],
+    temporaryDispatches: [],
+    cacheMethods: {},
+    cacheFields: {},
+    state: defaultState,
+    initialized: hasDefaultState,
+    controlled: !!controlled,
+    isSubscribing: false,
+    config: config2,
+    payload: function payload(setter) {
+      if (typeof setter === "function") {
+        updater.sidePayload = setter(updater.sidePayload);
       }
-      var f = d;
-      return f.identifier === cacheIdentify.field;
+      return updater.sidePayload;
     },
-    method: function method(d) {
-      if (typeof d !== "function") {
-        return false;
+    mutate: function mutate(callback) {
+      var effects = [];
+      var runEffects = function runEffects2(u) {
+        effects.forEach(function(e) {
+          return e(u);
+        });
+      };
+      var result = callback(updater, function(effectFn) {
+        return effects.push(effectFn);
+      });
+      if (updater === result) {
+        runEffects(result);
+        return updater;
       }
-      var m = d;
-      return m.identifier === cacheIdentify.method;
+      Object.assign(updater, result);
+      runEffects(updater);
+      return updater;
+    },
+    update: function(args) {
+    },
+    destroy: function destroy1() {
+      destroy(updater);
     }
-  };
-  function wrapToField(cache, propertyName, value, onGot) {
-    var cacheFields = cache.cacheFields;
-    if (!cacheIdentify.field(value)) {
-      if (onGot) {
-        onGot(propertyName, value);
-      }
-      return value;
+  }, unInitializedUpdater);
+  var initialized = createInitializedUpdater(updater, middleWare);
+  Object.assign(updater, initialized, {
+    update: createUpdateFn(updater, middleWare)
+  });
+  return updater;
+}
+
+// src/defaults.ts
+function defaultSelector(i) {
+  return i();
+}
+
+// src/store/cache.ts
+var cacheIdentify = {
+  field: function field(d) {
+    if (!d) {
+      return false;
     }
-    var field2 = value;
-    var cachedField = cacheFields[propertyName];
-    if (cachedField) {
-      return cachedField.getter;
+    var f = d;
+    return f.identifier === cacheIdentify.field;
+  },
+  method: function method(d) {
+    if (typeof d !== "function") {
+      return false;
     }
-    var getter = {
-      get: function get() {
-        var currentField = cache.target[propertyName];
-        if (!cacheIdentify.field(currentField)) {
-          throw new Error("Field should always be field.");
-        }
-        var current = currentField.get();
-        var fieldInCache = cache.cacheFields[propertyName];
-        if (!currentField.deps || fieldInCache == null) {
-          cacheFields[propertyName] = {
-            getter,
-            value: current,
-            deps: currentField.deps
-          };
-          return current;
-        }
-        if (shallowEqual(currentField.deps, fieldInCache.deps)) {
-          return fieldInCache.value;
-        }
+    var m = d;
+    return m.identifier === cacheIdentify.method;
+  }
+};
+function wrapToField(cache, propertyName, value, onGot) {
+  var cacheFields = cache.cacheFields;
+  if (!cacheIdentify.field(value)) {
+    if (onGot) {
+      onGot(propertyName, value);
+    }
+    return value;
+  }
+  var field2 = value;
+  var cachedField = cacheFields[propertyName];
+  if (cachedField) {
+    return cachedField.getter;
+  }
+  var getter = {
+    get: function get() {
+      var currentField = cache.target[propertyName];
+      if (!cacheIdentify.field(currentField)) {
+        throw new Error("Field should always be field.");
+      }
+      var current = currentField.get();
+      var fieldInCache = cache.cacheFields[propertyName];
+      if (!currentField.deps || fieldInCache == null) {
         cacheFields[propertyName] = {
           getter,
           value: current,
@@ -803,171 +830,171 @@
         };
         return current;
       }
-    };
-    cacheFields[propertyName] = {
-      getter,
-      value: field2.value,
-      deps: field2.deps
-    };
-    return getter;
+      if (shallowEqual(currentField.deps, fieldInCache.deps)) {
+        return fieldInCache.value;
+      }
+      cacheFields[propertyName] = {
+        getter,
+        value: current,
+        deps: currentField.deps
+      };
+      return current;
+    }
+  };
+  cacheFields[propertyName] = {
+    getter,
+    value: field2.value,
+    deps: field2.deps
+  };
+  return getter;
+}
+function wrapToActionMethod(cache, methodName) {
+  var cacheMethods = cache.cacheMethods;
+  var cachedMethod = cacheMethods[methodName];
+  if (typeof cachedMethod === "function") {
+    return cachedMethod;
   }
-  function wrapToActionMethod(cache, methodName) {
-    var cacheMethods = cache.cacheMethods;
-    var cachedMethod = cacheMethods[methodName];
-    if (typeof cachedMethod === "function") {
-      return cachedMethod;
+  var actionMethod = function actionMethod2() {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
     }
-    var actionMethod = function actionMethod2() {
-      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-        args[_key] = arguments[_key];
-      }
-      var target = cache.target;
-      var method2 = target[methodName];
-      if (typeof method2 !== "function") {
-        throw new Error("Can not change methods in runtime.");
+    var target = cache.target;
+    var method2 = target[methodName];
+    if (typeof method2 !== "function") {
+      throw new Error("Can not change methods in runtime.");
+    }
+    return method2.apply(void 0, _to_consumable_array(args));
+  };
+  cacheMethods[methodName] = actionMethod;
+  return actionMethod;
+}
+var cacheProperties = function(cache, onGet) {
+  return function createCachePropertiesProxy() {
+    var instance = cache.target;
+    var properties = Object.getOwnPropertyNames(instance);
+    var handleGetter = function handleGetter2(key, value) {
+      if (!onGet) {
+        return;
       }
-      return method2.apply(void 0, _to_consumable_array(args));
+      onGet(key, value);
     };
-    cacheMethods[methodName] = actionMethod;
-    return actionMethod;
-  }
-  var cacheProperties = function(cache, onGet) {
-    return function createCachePropertiesProxy() {
-      var instance = cache.target;
-      var properties = Object.getOwnPropertyNames(instance);
-      var handleGetter = function handleGetter2(key, value) {
-        if (!onGet) {
-          return;
-        }
-        onGet(key, value);
-      };
-      return createProxy(instance, {
-        get: function get(target, p) {
-          var value = target[p];
-          if (typeof value === "function" && properties.indexOf(p) >= 0) {
-            var actionMethod = wrapToActionMethod(cache, p);
-            Object.assign(actionMethod, value);
-            handleGetter(p, actionMethod);
-            return actionMethod;
-          }
-          return wrapToField(cache, p, value, handleGetter);
-        },
-        set: function set() {
-          return false;
+    return createProxy(instance, {
+      get: function get(target, p) {
+        var value = target[p];
+        if (typeof value === "function" && properties.indexOf(p) >= 0) {
+          var actionMethod = wrapToActionMethod(cache, p);
+          Object.assign(actionMethod, value);
+          handleGetter(p, actionMethod);
+          return actionMethod;
         }
-      });
-    };
+        return wrapToField(cache, p, value, handleGetter);
+      },
+      set: function set() {
+        return false;
+      }
+    });
   };
+};
 
-  // src/store/instance.ts
-  function createField(callback, deps) {
-    var currentDeps = function computeDeps() {
-      if (deps == null) {
-        return deps;
-      }
-      if (deps.some(function(d) {
-        return cacheIdentify.field(d) && d.deps == null;
-      })) {
-        return void 0;
-      }
-      return deps.flatMap(function(d) {
-        if (cacheIdentify.field(d)) {
-          return d.deps;
-        }
-        return d;
-      });
-    }();
-    var value = callback();
-    return {
-      callback,
-      deps: currentDeps,
-      identifier: cacheIdentify.field,
-      value,
-      get: function get() {
-        return value;
+// src/store/instance.ts
+function createField(callback, deps) {
+  var currentDeps = function computeDeps() {
+    if (deps == null) {
+      return deps;
+    }
+    if (deps.some(function(d) {
+      return cacheIdentify.field(d) && d.deps == null;
+    })) {
+      return void 0;
+    }
+    return deps.flatMap(function(d) {
+      if (cacheIdentify.field(d)) {
+        return d.deps;
       }
-    };
+      return d;
+    });
+  }();
+  var value = callback();
+  return {
+    callback,
+    deps: currentDeps,
+    identifier: cacheIdentify.field,
+    value,
+    get: function get() {
+      return value;
+    }
+  };
+}
+function createMethod(method2) {
+  var replace = function replace2() {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    return method2.apply(void 0, _to_consumable_array(args));
+  };
+  replace.identifier = cacheIdentify.method;
+  return replace;
+}
+function wrapToActionMethod2(updater, methodName) {
+  var cacheMethods = updater.cacheMethods;
+  var cachedMethod = cacheMethods[methodName];
+  if (typeof cachedMethod === "function") {
+    return cachedMethod;
   }
-  function createMethod(method2) {
-    var replace = function replace2() {
-      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-        args[_key] = arguments[_key];
-      }
+  var actionMethod = function actionMethod2() {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    var instance = updater.instance;
+    var method2 = instance[methodName];
+    if (typeof method2 !== "function") {
+      throw new Error("Can not change methods in runtime.");
+    }
+    if (cacheIdentify.method(method2)) {
       return method2.apply(void 0, _to_consumable_array(args));
-    };
-    replace.identifier = cacheIdentify.method;
-    return replace;
-  }
-  function wrapToActionMethod2(updater, methodName) {
-    var cacheMethods = updater.cacheMethods;
-    var cachedMethod = cacheMethods[methodName];
-    if (typeof cachedMethod === "function") {
-      return cachedMethod;
     }
-    var actionMethod = function actionMethod2() {
-      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-        args[_key] = arguments[_key];
-      }
-      var instance = updater.instance;
-      var method2 = instance[methodName];
-      if (typeof method2 !== "function") {
-        throw new Error("Can not change methods in runtime.");
-      }
-      if (cacheIdentify.method(method2)) {
-        return method2.apply(void 0, _to_consumable_array(args));
-      }
-      var state = method2.apply(void 0, _to_consumable_array(args));
-      var action = {
-        type: methodName,
-        state,
-        prevState: updater.state,
-        instance: updater.instance,
-        prevInstance: updater.instance,
-        method: actionMethod2
-      };
-      updater.notify(action);
-      return state;
+    var state = method2.apply(void 0, _to_consumable_array(args));
+    var action = {
+      type: methodName,
+      state,
+      prevState: updater.state,
+      instance: updater.instance,
+      prevInstance: updater.instance,
+      method: actionMethod2
     };
-    cacheMethods[methodName] = actionMethod;
-    return actionMethod;
+    updater.notify(action);
+    return state;
+  };
+  cacheMethods[methodName] = actionMethod;
+  return actionMethod;
+}
+function wrapToField2(updater, propertyName, value, onGot) {
+  function collect(pName, v) {
+    if (onGot) {
+      onGot(pName, v);
+    }
+  }
+  var cacheFields = updater.cacheFields;
+  if (!cacheIdentify.field(value)) {
+    collect(propertyName, value);
+    return value;
+  }
+  var field2 = value;
+  var cachedField = cacheFields[propertyName];
+  if (cachedField && (field2.deps && shallowEqual(cachedField.deps, field2.deps) || !field2.deps && cachedField.value === field2.value)) {
+    var cacheFieldGetter = cachedField.getter;
+    collect(propertyName, cacheFieldGetter);
+    return cacheFieldGetter;
   }
-  function wrapToField2(updater, propertyName, value, onGot) {
-    function collect(pName, v) {
-      if (onGot) {
-        onGot(pName, v);
+  var getter = {
+    get: function get() {
+      var currentField = updater.instance[propertyName];
+      if (!cacheIdentify.field(currentField)) {
+        throw new Error("Field should always be field.");
       }
-    }
-    var cacheFields = updater.cacheFields;
-    if (!cacheIdentify.field(value)) {
-      collect(propertyName, value);
-      return value;
-    }
-    var field2 = value;
-    var cachedField = cacheFields[propertyName];
-    if (cachedField && (field2.deps && shallowEqual(cachedField.deps, field2.deps) || !field2.deps && cachedField.value === field2.value)) {
-      var cacheFieldGetter = cachedField.getter;
-      collect(propertyName, cacheFieldGetter);
-      return cacheFieldGetter;
-    }
-    var getter = {
-      get: function get() {
-        var currentField = updater.instance[propertyName];
-        if (!cacheIdentify.field(currentField)) {
-          throw new Error("Field should always be field.");
-        }
-        var current = currentField.get();
-        var fieldInCache = updater.cacheFields[propertyName];
-        if (!currentField.deps || fieldInCache == null) {
-          cacheFields[propertyName] = {
-            getter,
-            value: current,
-            deps: currentField.deps
-          };
-          return current;
-        }
-        if (shallowEqual(currentField.deps, fieldInCache.deps)) {
-          return fieldInCache.value;
-        }
+      var current = currentField.get();
+      var fieldInCache = updater.cacheFields[propertyName];
+      if (!currentField.deps || fieldInCache == null) {
         cacheFields[propertyName] = {
           getter,
           value: current,
@@ -975,29 +1002,40 @@
         };
         return current;
       }
-    };
-    cacheFields[propertyName] = {
-      getter,
-      value: field2.value,
-      deps: field2.deps
-    };
-    collect(propertyName, getter);
-    return getter;
-  }
-  function extractInstance(updater, wrapper, cache, opts) {
-    var onGet = (opts || {}).onGet;
-    var handleGetter = function handleGetter2(key, value) {
-      if (!onGet) {
-        return;
+      if (shallowEqual(currentField.deps, fieldInCache.deps)) {
+        return fieldInCache.value;
       }
-      onGet(key, value);
-    };
+      cacheFields[propertyName] = {
+        getter,
+        value: current,
+        deps: currentField.deps
+      };
+      return current;
+    }
+  };
+  cacheFields[propertyName] = {
+    getter,
+    value: field2.value,
+    deps: field2.deps
+  };
+  collect(propertyName, getter);
+  return getter;
+}
+function extractInstance(updater, wrapper, cache, opts) {
+  var onGet = (opts || {}).onGet;
+  var handleGetter = function handleGetter2(key, value) {
+    if (!onGet) {
+      return;
+    }
+    onGet(key, value);
+  };
+  function generateInstance() {
     var instance = updater.instance;
     if ((typeof instance === "undefined" ? "undefined" : _type_of(instance)) !== "object" || !instance) {
       throw new Error("The instance should be an object or array.");
     }
     var properties = Object.getOwnPropertyNames(instance);
-    var proxiedInstance = createProxy(instance, {
+    return createProxy(instance, {
       get: function get(target, p) {
         var value = target[p];
         if (typeof value === "function" && properties.indexOf(p) >= 0) {
@@ -1011,435 +1049,436 @@
         return false;
       }
     });
-    function generateInstance() {
-      return proxiedInstance;
-    }
-    if (wrapper == null) {
-      return proxiedInstance;
-    }
-    var wrapped = wrapper(generateInstance);
-    if ((typeof wrapped === "undefined" ? "undefined" : _type_of(wrapped)) === "object" && wrapped != null) {
-      return cacheProperties(_object_spread_props(_object_spread({}, cache), {
-        target: wrapped
-      }), handleGetter)();
-    }
-    return wrapped;
   }
+  var proxiedInstance = generateInstance();
+  if (wrapper == null || wrapper === defaultSelector) {
+    return proxiedInstance;
+  }
+  if (wrapper === defaultSelector) {
+    return cacheProperties(_object_spread_props(_object_spread({}, cache), {
+      target: proxiedInstance
+    }), handleGetter)();
+  }
+  var wrapped = wrapper(generateInstance);
+  if ((typeof wrapped === "undefined" ? "undefined" : _type_of(wrapped)) === "object" && wrapped != null) {
+    return cacheProperties(_object_spread_props(_object_spread({}, cache), {
+      target: wrapped
+    }), handleGetter)();
+  }
+  return wrapped;
+}
 
-  // src/store/enhance/signal.ts
-  function createSignal(store) {
-    var signalStore = {
-      collection: {},
-      started: false,
-      enabled: false
-    };
-    var propertiesCache = {
-      target: store.getInstance(),
-      cacheFields: {},
-      cacheMethods: {}
-    };
-    var enhance = function(dispatcher) {
-      return function(action) {
-        if (!signalStore.enabled) {
-          dispatcher === null || dispatcher === void 0 ? void 0 : dispatcher(action);
-          return;
-        }
-        var collection = signalStore.collection;
-        if (collection == null) {
-          return;
+// src/store/enhance/signal.ts
+function createSignal(store) {
+  var signalStore = {
+    collection: {},
+    started: false,
+    enabled: false
+  };
+  var propertiesCache = {
+    target: store.getInstance(),
+    cacheFields: {},
+    cacheMethods: {}
+  };
+  var enhance = function(dispatcher) {
+    return function(action) {
+      if (!signalStore.enabled) {
+        dispatcher === null || dispatcher === void 0 ? void 0 : dispatcher(action);
+        return;
+      }
+      var collection = signalStore.collection;
+      if (collection == null) {
+        return;
+      }
+      var storeInstance = extractInstance(store.updater, store.key.wrapper, propertiesCache);
+      var keys = Object.keys(collection);
+      if (!keys.length) {
+        return;
+      }
+      var hasChange = keys.some(function(key) {
+        var field2 = storeInstance[key];
+        var collectedField = collection[key];
+        if (cacheIdentify.field(field2) && cacheIdentify.field(collectedField)) {
+          return field2.get() !== collectedField.get();
         }
-        var storeInstance = extractInstance(store.updater, store.key.wrapper, propertiesCache);
-        var keys = Object.keys(collection);
-        if (!keys.length) {
+        return field2 !== collectedField;
+      });
+      if (hasChange) {
+        dispatcher === null || dispatcher === void 0 ? void 0 : dispatcher(action);
+      }
+    };
+  };
+  var storeKey = store.key;
+  return {
+    key: storeKey,
+    getToken: function getToken() {
+      return store.getToken();
+    },
+    subscribe: function subscribe(dispatcher) {
+      return store.subscribe(enhance(dispatcher));
+    },
+    getSignal: function getSignal() {
+      var collectUsedFields = function collectUsedFields2(key, val) {
+        if (!signalStore.started) {
           return;
         }
-        var hasChange = keys.some(function(key) {
-          var field2 = storeInstance[key];
-          var collectedField = collection[key];
-          if (cacheIdentify.field(field2) && cacheIdentify.field(collectedField)) {
-            return field2.get() !== collectedField.get();
-          }
-          return field2 !== collectedField;
+        signalStore.collection[key] = val;
+      };
+      var getInstance = function getInstance2(options) {
+        var cutOff = (options !== null && options !== void 0 ? options : {}).cutOff;
+        return extractInstance(store.updater, store.key.wrapper, propertiesCache, {
+          onGet: cutOff ? void 0 : collectUsedFields
         });
-        if (hasChange) {
-          dispatcher === null || dispatcher === void 0 ? void 0 : dispatcher(action);
-        }
       };
-    };
-    var storeKey = store.key;
-    return {
-      key: storeKey,
-      getToken: function getToken() {
-        return store.getToken();
-      },
-      subscribe: function subscribe(dispatcher) {
-        return store.subscribe(enhance(dispatcher));
-      },
-      getSignal: function getSignal() {
-        var collectUsedFields = function collectUsedFields2(key, val) {
-          if (!signalStore.started) {
-            return;
-          }
-          signalStore.collection[key] = val;
-        };
-        var getInstance = function getInstance2(options) {
-          var cutOff = (options !== null && options !== void 0 ? options : {}).cutOff;
-          return extractInstance(store.updater, store.key.wrapper, propertiesCache, {
-            onGet: cutOff ? void 0 : collectUsedFields
-          });
-        };
-        var signal = function signal2(options) {
-          return getInstance(options);
-        };
-        signal.startStatistics = function startStatistics() {
-          signalStore.started = true;
-          signalStore.collection = {};
-        };
-        signal.stopStatistics = function stopStatistics() {
-          signalStore.started = false;
-        };
-        signal.subscribe = function subscribe(dispatchCallback) {
-          return store.subscribe(dispatchCallback);
-        };
-        signal.store = store;
-        signalStore.enabled = true;
+      var signal = function signal2(options) {
+        return getInstance(options);
+      };
+      signal.startStatistics = function startStatistics() {
         signalStore.started = true;
-        return signal;
-      }
-    };
-  }
+        signalStore.collection = {};
+      };
+      signal.stopStatistics = function stopStatistics() {
+        signalStore.started = false;
+      };
+      signal.subscribe = function subscribe(dispatchCallback) {
+        return store.subscribe(dispatchCallback);
+      };
+      signal.store = store;
+      signalStore.enabled = true;
+      signalStore.started = true;
+      return signal;
+    }
+  };
+}
 
-  // src/store/enhance/selector.ts
-  function createSelector(store, opts) {
-    var equality = (opts !== null && opts !== void 0 ? opts : {}).equality;
-    var selectStore = {
-      selectedInstance: store.getInstance()
-    };
-    var cache = {
-      equality,
-      setSelect: function setSelect(selector) {
-        cache.selector = selector;
-        if (!selector) {
-          return;
-        }
-        var currentSelectedInstance = selectStore.selectedInstance;
-        var nextSelectedInstance = selector(store.getInstance);
-        if (currentSelectedInstance === nextSelectedInstance || equality && equality(currentSelectedInstance, nextSelectedInstance)) {
-          return;
-        }
-        selectStore.selectedInstance = nextSelectedInstance;
+// src/store/enhance/selector.ts
+function createSelector(store, opts) {
+  var equality = (opts !== null && opts !== void 0 ? opts : {}).equality;
+  var selectStore = {
+    selectedInstance: store.getInstance()
+  };
+  var cache = {
+    equality,
+    setSelect: function setSelect(selector) {
+      cache.selector = selector;
+      if (!selector) {
+        return;
       }
-    };
-    var generateSelectedInstance = function generateSelectedInstance2(getInstance) {
-      if (cache.selector) {
-        return cache.selector(getInstance);
+      var currentSelectedInstance = selectStore.selectedInstance;
+      var nextSelectedInstance = selector(store.getInstance);
+      if (currentSelectedInstance === nextSelectedInstance || equality && equality(currentSelectedInstance, nextSelectedInstance)) {
+        return;
       }
-      return getInstance();
-    };
-    selectStore.selectedInstance = generateSelectedInstance(store.getInstance);
-    var enhance = function(dispatcher) {
-      return function(action) {
-        var currentSelectedInstance = selectStore.selectedInstance;
-        var nextSelectedInstance = generateSelectedInstance(store.getInstance);
-        if (currentSelectedInstance === nextSelectedInstance || cache.equality && cache.equality(currentSelectedInstance, nextSelectedInstance)) {
-          return;
-        }
-        selectStore.selectedInstance = nextSelectedInstance;
-        if (dispatcher == null) {
-          return;
-        }
-        dispatcher(action);
-      };
-    };
-    function select(selector) {
-      cache.setSelect(selector);
-      return selectStore.selectedInstance;
+      selectStore.selectedInstance = nextSelectedInstance;
     }
-    return {
-      key: store.key,
-      getToken: function getToken() {
-        return store.getToken();
-      },
-      subscribe: function subscribe(dispatcher) {
-        return store.subscribe(enhance(dispatcher));
-      },
-      select
-    };
-  }
-
-  // src/store/index.ts
-  function createPrimaryKey(modelFn) {
-    var config2 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
-    var ifModelKey = isModelKey(modelFn);
-    var ifModelUsage = isModelUsage(modelFn);
-    var model2 = ifModelKey ? modelFn.source : modelFn;
-    var _config_wrapper;
-    var wrapper = (_config_wrapper = config2.wrapper) !== null && _config_wrapper !== void 0 ? _config_wrapper : ifModelKey || ifModelUsage ? modelFn.wrapper : function defaultSelector(i) {
-      return i();
-    };
-    var wrapModel = function wrapModel2(state) {
-      return model2(state);
-    };
-    wrapModel.source = model2;
-    wrapModel.wrapper = wrapper;
-    wrapModel.modelKeyIdentifier = modelKeyIdentifier;
-    if ("state" in config2) {
-      wrapModel.defaultState = config2.state;
+  };
+  var generateSelectedInstance = function generateSelectedInstance2(getInstance) {
+    if (cache.selector) {
+      return cache.selector(getInstance);
     }
-    return wrapModel;
-  }
-  function createStore(modelLike) {
-    var config2 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
-    var ifModelKey = isModelKey(modelLike);
-    var model2 = ifModelKey ? modelLike.source : modelLike;
-    var modelKey = ifModelKey ? modelLike : void 0;
-    var conf = function computeConfig() {
-      var hasConfigState = "state" in config2;
-      var hasKeyState = !!modelKey && "defaultState" in modelKey;
-      if (hasConfigState) {
-        return config2;
+    return getInstance();
+  };
+  selectStore.selectedInstance = generateSelectedInstance(store.getInstance);
+  var enhance = function(dispatcher) {
+    return function(action) {
+      var currentSelectedInstance = selectStore.selectedInstance;
+      var nextSelectedInstance = generateSelectedInstance(store.getInstance);
+      if (currentSelectedInstance === nextSelectedInstance || cache.equality && cache.equality(currentSelectedInstance, nextSelectedInstance)) {
+        return;
       }
-      if (hasKeyState) {
-        return _object_spread_props(_object_spread({}, config2), {
-          state: modelKey === null || modelKey === void 0 ? void 0 : modelKey.defaultState
-        });
+      selectStore.selectedInstance = nextSelectedInstance;
+      if (dispatcher == null) {
+        return;
       }
-      return config2;
-    }();
-    var combinedMiddleWare = function combinedMiddleWare2(s) {
-      return function updaterMiddleWare(next) {
-        var middleWares = conf.middleWares;
-        if (middleWares == null) {
-          return next;
-        }
-        var updateMiddleWares = _to_consumable_array(middleWares).reverse().map(function(middleWare) {
-          return middleWare(s);
-        });
-        return updateMiddleWares.reduce(function(finalDispatcher, um) {
-          return um(finalDispatcher);
-        }, next);
-      };
-    };
-    var updater = createUpdater(model2, combinedMiddleWare, conf);
-    var key = modelKey !== null && modelKey !== void 0 ? modelKey : createPrimaryKey(model2, config2);
-    var propertiesCache = {
-      target: updater.instance,
-      cacheFields: {},
-      cacheMethods: {}
+      dispatcher(action);
     };
-    var store = {
-      key,
-      getToken: function getToken() {
-        return updater.token;
-      },
-      subscribe: function subscribe(dispatcher) {
-        var _updater_createTunnel = updater.createTunnel(dispatcher || noop), connect = _updater_createTunnel.connect, disconnect = _updater_createTunnel.disconnect;
-        connect();
-        return disconnect;
-      },
-      getInstance: function getInstance() {
-        return extractInstance(updater, key.wrapper, propertiesCache);
-      },
-      getStoreInstance: function getStoreInstance() {
-        return extractInstance(updater, void 0, propertiesCache);
-      },
-      update: function update(args) {
-        var updateArgs = args !== null && args !== void 0 ? args : {};
-        if (updateArgs.key) {
-          var updatingKey = updateArgs.key, updatingModel = updateArgs.model, rest = _object_without_properties(updateArgs, [
-            "key",
-            "model"
-          ]);
-          updater.update(_object_spread_props(_object_spread({}, rest), {
-            model: updatingKey.source
-          }));
-          store.key = updatingKey;
-          return;
-        }
-        if (updateArgs.model) {
-          var updatingKey1 = updateArgs.key, updatingModel1 = updateArgs.model, rest1 = _object_without_properties(updateArgs, [
-            "key",
-            "model"
-          ]);
-          updater.update(_object_spread_props(_object_spread({}, rest1), {
-            model: updatingModel1
-          }));
-          store.key = createPrimaryKey(updatingModel1, config2);
-          return;
-        }
-        updater.update(args);
-      },
-      destroy: function destroy2() {
-        updater.destroy();
-      },
-      payload: function payload(callback) {
-        return updater.payload(callback);
-      },
-      isDestroyed: function isDestroyed() {
-        return updater.isDestroyed;
-      },
-      extends: function _extends(e) {
-        return Object.assign(store, e);
-      },
-      updater,
-      modelStoreIdentifier
-    };
-    return store;
+  };
+  function select(selector) {
+    cache.setSelect(selector);
+    return selectStore.selectedInstance;
   }
-  var createField2 = createField;
-  var createMethod2 = createMethod;
+  return {
+    key: store.key,
+    getToken: function getToken() {
+      return store.getToken();
+    },
+    subscribe: function subscribe(dispatcher) {
+      return store.subscribe(enhance(dispatcher));
+    },
+    select
+  };
+}
 
-  // src/key/index.ts
-  function createKey(model2) {
-    var config2 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
-    var wrapModel = createPrimaryKey(model2, config2);
-    wrapModel.createStore = function createKeyStore() {
-      var storeConfig = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
-      return createStore(wrapModel, _object_spread({}, config2, storeConfig));
-    };
-    wrapModel.extends = function extendsKey(e) {
-      return Object.assign(wrapModel, e);
-    };
-    return wrapModel;
+// src/store/index.ts
+function createPrimaryKey(modelFn) {
+  var config2 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+  var ifModelKey = isModelKey(modelFn);
+  var ifModelUsage = isModelUsage(modelFn);
+  var model2 = ifModelKey ? modelFn.source : modelFn;
+  var _config_wrapper;
+  var wrapper = (_config_wrapper = config2.wrapper) !== null && _config_wrapper !== void 0 ? _config_wrapper : ifModelKey || ifModelUsage ? modelFn.wrapper : function defaultSelector2(i) {
+    return i();
+  };
+  var wrapModel = function wrapModel2(state) {
+    return model2(state);
+  };
+  wrapModel.source = model2;
+  wrapModel.wrapper = wrapper;
+  wrapModel.modelKeyIdentifier = modelKeyIdentifier;
+  if ("state" in config2) {
+    wrapModel.defaultState = config2.state;
   }
-  createKey.isModelKey = isModelKey;
-  function createStores(modelKeys) {
-    var config2 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
-    var state = {
-      destroyed: false
+  return wrapModel;
+}
+function createStore(modelLike) {
+  var config2 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+  var ifModelKey = isModelKey(modelLike);
+  var model2 = ifModelKey ? modelLike.source : modelLike;
+  var modelKey = ifModelKey ? modelLike : void 0;
+  var conf = function computeConfig() {
+    var hasConfigState = "state" in config2;
+    var hasKeyState = !!modelKey && "defaultState" in modelKey;
+    if (hasConfigState) {
+      return config2;
+    }
+    if (hasKeyState) {
+      return _object_spread_props(_object_spread({}, config2), {
+        state: modelKey === null || modelKey === void 0 ? void 0 : modelKey.defaultState
+      });
+    }
+    return config2;
+  }();
+  var combinedMiddleWare = function combinedMiddleWare2(s) {
+    return function updaterMiddleWare(next) {
+      var middleWares = conf.middleWares;
+      if (middleWares == null) {
+        return next;
+      }
+      var updateMiddleWares = _to_consumable_array(middleWares).reverse().map(function(middleWare) {
+        return middleWare(s);
+      });
+      return updateMiddleWares.reduce(function(finalDispatcher, um) {
+        return um(finalDispatcher);
+      }, next);
     };
-    var storeUnits = modelKeys.map(function(modelKey) {
-      if (typeof modelKey === "function") {
-        return modelKey.createStore();
+  };
+  var updater = createUpdater(model2, combinedMiddleWare, conf);
+  var key = modelKey !== null && modelKey !== void 0 ? modelKey : createPrimaryKey(model2, config2);
+  var propertiesCache = {
+    target: updater.instance,
+    cacheFields: {},
+    cacheMethods: {}
+  };
+  var store = {
+    key,
+    getToken: function getToken() {
+      return updater.token;
+    },
+    subscribe: function subscribe(dispatcher) {
+      var _updater_createTunnel = updater.createTunnel(dispatcher || noop), connect = _updater_createTunnel.connect, disconnect = _updater_createTunnel.disconnect;
+      connect();
+      return disconnect;
+    },
+    getInstance: function getInstance() {
+      return extractInstance(updater, key.wrapper, propertiesCache);
+    },
+    getStoreInstance: function getStoreInstance() {
+      return extractInstance(updater, void 0, propertiesCache);
+    },
+    update: function update(args) {
+      var updateArgs = args !== null && args !== void 0 ? args : {};
+      if (updateArgs.key) {
+        var updatingKey = updateArgs.key, updatingModel = updateArgs.model, rest = _object_without_properties(updateArgs, [
+          "key",
+          "model"
+        ]);
+        updater.update(_object_spread_props(_object_spread({}, rest), {
+          model: updatingKey.source
+        }));
+        store.key = updatingKey;
+        return;
       }
-      var k = modelKey.key;
-      return createStore(k, "defaultState" in k ? _object_spread_props(_object_spread({}, config2), {
-        state: k.defaultState
-      }) : config2);
-    });
-    return {
-      find: function find(key) {
-        var found = storeUnits.find(function(c) {
-          if (typeof key === "function") {
-            return c.key === key;
-          }
-          return c.key === key.key;
-        });
-        if (!found) {
-          return null;
-        }
-        return found;
-      },
-      update: function update() {
-        for (var _len = arguments.length, keys = new Array(_len), _key = 0; _key < _len; _key++) {
-          keys[_key] = arguments[_key];
+      if (updateArgs.model) {
+        var updatingKey1 = updateArgs.key, updatingModel1 = updateArgs.model, rest1 = _object_without_properties(updateArgs, [
+          "key",
+          "model"
+        ]);
+        updater.update(_object_spread_props(_object_spread({}, rest1), {
+          model: updatingModel1
+        }));
+        store.key = createPrimaryKey(updatingModel1, config2);
+        return;
+      }
+      updater.update(args);
+    },
+    destroy: function destroy2() {
+      updater.destroy();
+    },
+    payload: function payload(callback) {
+      return updater.payload(callback);
+    },
+    isDestroyed: function isDestroyed() {
+      return updater.isDestroyed;
+    },
+    extends: function _extends(e) {
+      return Object.assign(store, e);
+    },
+    updater,
+    modelStoreIdentifier
+  };
+  return store;
+}
+var createField2 = createField;
+var createMethod2 = createMethod;
+
+// src/key/index.ts
+function createKey(model2) {
+  var config2 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+  var wrapModel = createPrimaryKey(model2, config2);
+  wrapModel.createStore = function createKeyStore() {
+    var storeConfig = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+    return createStore(wrapModel, _object_spread({}, config2, storeConfig));
+  };
+  wrapModel.extends = function extendsKey(e) {
+    return Object.assign(wrapModel, e);
+  };
+  return wrapModel;
+}
+createKey.isModelKey = isModelKey;
+function createStores(modelKeys) {
+  var config2 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+  var state = {
+    destroyed: false
+  };
+  var storeUnits = modelKeys.map(function(modelKey) {
+    if (typeof modelKey === "function") {
+      return modelKey.createStore();
+    }
+    var k = modelKey.key;
+    return createStore(k, "defaultState" in k ? _object_spread_props(_object_spread({}, config2), {
+      state: k.defaultState
+    }) : config2);
+  });
+  return {
+    find: function find(key) {
+      var found = storeUnits.find(function(c) {
+        if (typeof key === "function") {
+          return c.key === key;
         }
-        if (state.destroyed) {
+        return c.key === key.key;
+      });
+      if (!found) {
+        return null;
+      }
+      return found;
+    },
+    update: function update() {
+      for (var _len = arguments.length, keys = new Array(_len), _key = 0; _key < _len; _key++) {
+        keys[_key] = arguments[_key];
+      }
+      if (state.destroyed) {
+        return;
+      }
+      storeUnits.forEach(function(un, i) {
+        var keyLike = keys[i];
+        if (!keyLike) {
           return;
         }
-        storeUnits.forEach(function(un, i) {
-          var keyLike = keys[i];
-          if (!keyLike) {
-            return;
-          }
-          var ifIsModelKey = validations.isModelKey(keyLike);
-          var key = ifIsModelKey ? keyLike : keyLike.key;
-          un.update({
-            key
-          });
-        });
-      },
-      keys: function keys() {
-        return storeUnits.map(function(param) {
-          var key = param.key;
-          return key;
-        });
-      },
-      destroy: function destroy2() {
-        storeUnits.forEach(function(unit) {
-          unit.destroy();
+        var ifIsModelKey = validations.isModelKey(keyLike);
+        var key = ifIsModelKey ? keyLike : keyLike.key;
+        un.update({
+          key
         });
-        state.destroyed = true;
-      }
-    };
-  }
+      });
+    },
+    keys: function keys() {
+      return storeUnits.map(function(param) {
+        var key = param.key;
+        return key;
+      });
+    },
+    destroy: function destroy2() {
+      storeUnits.forEach(function(unit) {
+        unit.destroy();
+      });
+      state.destroyed = true;
+    }
+  };
+}
 
-  // src/model/index.ts
-  function configModel(config2) {
-    var model2 = function model3(modelFn, wrapper) {
-      var currentSelector = wrapper !== null && wrapper !== void 0 ? wrapper : function defaultSelector(i) {
-        return i();
-      };
-      var modelWrapper = function modelWrapper2(state) {
-        return modelFn(state);
-      };
-      modelWrapper.produce = function produce(s) {
-        return model3(modelFn, s);
-      };
-      modelWrapper.createKey = function createModelKey(state) {
-        return createKey(modelFn, arguments.length ? _object_spread_props(_object_spread({}, config2), {
-          state,
-          wrapper: currentSelector
-        }) : _object_spread_props(_object_spread({}, config2), {
-          wrapper: currentSelector
-        }));
-      };
-      modelWrapper.createStore = function createModelStore(state) {
-        return createStore(modelFn, arguments.length ? _object_spread_props(_object_spread({}, config2), {
-          state,
-          wrapper: currentSelector
-        }) : _object_spread_props(_object_spread({}, config2), {
-          wrapper: currentSelector
-        }));
-      };
-      modelWrapper.extends = function extendsModelUsage(e) {
-        return Object.assign(modelWrapper, e);
-      };
-      modelWrapper.wrapper = currentSelector;
-      modelWrapper.modelUsageIdentifier = modelUsageIdentifier;
-      return modelWrapper;
+// src/model/index.ts
+function configModel(config2) {
+  var model2 = function model3(modelFn, wrapper) {
+    var currentSelector = wrapper !== null && wrapper !== void 0 ? wrapper : defaultSelector;
+    var modelWrapper = function modelWrapper2(state) {
+      return modelFn(state);
     };
-    model2.createField = createField2;
-    model2.createMethod = createMethod2;
-    return model2;
-  }
-
-  // src/index.ts
-  function config() {
-    var configuration = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
-    var createStore3 = function createStore4(modelLike, state) {
-      return createStore(modelLike, arguments.length > 1 ? _object_spread_props(_object_spread({}, configuration), {
-        state
-      }) : configuration);
+    modelWrapper.produce = function produce(s) {
+      return model3(modelFn, s);
     };
-    var createKey3 = function createKey4(model3, state) {
-      var isKeySetState = arguments.length > 1;
-      var key = createKey(model3, isKeySetState ? _object_spread_props(_object_spread({}, configuration), {
-        state
-      }) : configuration);
-      key.createStore = function createKeyStore(s) {
-        return arguments.length > 0 ? createStore3(key, s) : createStore3(key);
-      };
-      return key;
+    modelWrapper.createKey = function createModelKey(state) {
+      return createKey(modelFn, arguments.length ? _object_spread_props(_object_spread({}, config2), {
+        state,
+        wrapper: currentSelector
+      }) : _object_spread_props(_object_spread({}, config2), {
+        wrapper: currentSelector
+      }));
     };
-    createKey3.isModelKey = createKey.isModelKey;
-    var createStores3 = function createStores4() {
-      for (var _len = arguments.length, modelKeys = new Array(_len), _key = 0; _key < _len; _key++) {
-        modelKeys[_key] = arguments[_key];
-      }
-      return createStores(modelKeys, configuration);
+    modelWrapper.createStore = function createModelStore(state) {
+      return createStore(modelFn, arguments.length ? _object_spread_props(_object_spread({}, config2), {
+        state,
+        wrapper: currentSelector
+      }) : _object_spread_props(_object_spread({}, config2), {
+        wrapper: currentSelector
+      }));
     };
-    var model2 = configModel(configuration);
-    return {
-      createStore: createStore3,
-      createKey: createKey3,
-      createStores: createStores3,
-      model: model2
+    modelWrapper.extends = function extendsModelUsage(e) {
+      return Object.assign(modelWrapper, e);
     };
-  }
-  var _config = config();
-  var createStore2 = _config.createStore;
-  var createKey2 = _config.createKey;
-  var createStores2 = _config.createStores;
-  var model = _config.model;
-})();
+    modelWrapper.wrapper = currentSelector;
+    modelWrapper.modelUsageIdentifier = modelUsageIdentifier;
+    return modelWrapper;
+  };
+  model2.createField = createField2;
+  model2.createMethod = createMethod2;
+  return model2;
+}
+
+// src/index.ts
+function config() {
+  var configuration = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+  var createStore3 = function createStore4(modelLike, state) {
+    return createStore(modelLike, arguments.length > 1 ? _object_spread_props(_object_spread({}, configuration), {
+      state
+    }) : configuration);
+  };
+  var createKey3 = function createKey4(model3, state) {
+    var isKeySetState = arguments.length > 1;
+    var key = createKey(model3, isKeySetState ? _object_spread_props(_object_spread({}, configuration), {
+      state
+    }) : configuration);
+    key.createStore = function createKeyStore(s) {
+      return arguments.length > 0 ? createStore3(key, s) : createStore3(key);
+    };
+    return key;
+  };
+  createKey3.isModelKey = createKey.isModelKey;
+  var createStores3 = function createStores4() {
+    for (var _len = arguments.length, modelKeys = new Array(_len), _key = 0; _key < _len; _key++) {
+      modelKeys[_key] = arguments[_key];
+    }
+    return createStores(modelKeys, configuration);
+  };
+  var model2 = configModel(configuration);
+  return {
+    createStore: createStore3,
+    createKey: createKey3,
+    createStores: createStores3,
+    model: model2
+  };
+}
+var _config = config();
+var createStore2 = _config.createStore;
+var createKey2 = _config.createKey;
+var createStores2 = _config.createStores;
+var model = _config.model;