mobx-react 6.1.7 → 6.1.8

package/dist/mobxreact.cjs.development.js

@@ -10,19 +10,19 @@ var React__default = _interopDefault(React);
 var reactDom = require('react-dom');
 var mobxReactLite = require('mobx-react-lite');
 
-let symbolId = 0;
+var symbolId = 0;
 
 function createSymbol(name) {
   if (typeof Symbol === "function") {
     return Symbol(name);
   }
 
-  const symbol = `__$mobx-react ${name} (${symbolId})`;
+  var symbol = "__$mobx-react " + name + " (" + symbolId + ")";
   symbolId++;
   return symbol;
 }
 
-const createdSymbols = {};
+var createdSymbols = {};
 function newSymbol(name) {
   if (!createdSymbols[name]) {
     createdSymbols[name] = createSymbol(name);
@@ -38,11 +38,11 @@ function shallowEqual(objA, objB) {
     return false;
   }
 
-  const keysA = Object.keys(objA);
-  const keysB = Object.keys(objB);
+  var keysA = Object.keys(objA);
+  var keysB = Object.keys(objB);
   if (keysA.length !== keysB.length) return false;
 
-  for (let i = 0; i < keysA.length; i++) {
+  for (var i = 0; i < keysA.length; i++) {
     if (!Object.hasOwnProperty.call(objB, keysA[i]) || !is(objA[keysA[i]], objB[keysA[i]])) {
       return false;
     }
@@ -61,7 +61,7 @@ function is(x, y) {
 } // based on https://github.com/mridgway/hoist-non-react-statics/blob/master/src/index.js
 
 
-const hoistBlackList = {
+var hoistBlackList = {
   $$typeof: 1,
   render: 1,
   compare: 1,
@@ -77,8 +77,8 @@ const hoistBlackList = {
   propTypes: 1
 };
 function copyStaticProperties(base, target) {
-  const protoProps = Object.getOwnPropertyNames(Object.getPrototypeOf(base));
-  Object.getOwnPropertyNames(base).forEach(key => {
+  var protoProps = Object.getOwnPropertyNames(Object.getPrototypeOf(base));
+  Object.getOwnPropertyNames(base).forEach(function (key) {
     if (!hoistBlackList[key] && protoProps.indexOf(key) === -1) {
       Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(base, key));
     }
@@ -97,7 +97,7 @@ function setHiddenProp(target, prop, value) {
       enumerable: false,
       configurable: true,
       writable: true,
-      value
+      value: value
     });
   } else {
     target[prop] = value;
@@ -108,27 +108,33 @@ function setHiddenProp(target, prop, value) {
  * and the handler provided by mobx-react
  */
 
-const mobxMixins =
+var mobxMixins =
 /*#__PURE__*/
 newSymbol("patchMixins");
-const mobxPatchedDefinition =
+var mobxPatchedDefinition =
 /*#__PURE__*/
 newSymbol("patchedDefinition");
 
 function getMixins(target, methodName) {
-  const mixins = target[mobxMixins] = target[mobxMixins] || {};
-  const methodMixins = mixins[methodName] = mixins[methodName] || {};
+  var mixins = target[mobxMixins] = target[mobxMixins] || {};
+  var methodMixins = mixins[methodName] = mixins[methodName] || {};
   methodMixins.locks = methodMixins.locks || 0;
   methodMixins.methods = methodMixins.methods || [];
   return methodMixins;
 }
 
-function wrapper(realMethod, mixins, ...args) {
+function wrapper(realMethod, mixins) {
+  var _this = this;
+
+  for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+    args[_key - 2] = arguments[_key];
+  }
+
   // locks are used to ensure that mixins are invoked only once per invocation, even on recursive calls
   mixins.locks++;
 
   try {
-    let retVal;
+    var retVal;
 
     if (realMethod !== undefined && realMethod !== null) {
       retVal = realMethod.apply(this, args);
@@ -139,76 +145,76 @@ function wrapper(realMethod, mixins, ...args) {
     mixins.locks--;
 
     if (mixins.locks === 0) {
-      mixins.methods.forEach(mx => {
-        mx.apply(this, args);
+      mixins.methods.forEach(function (mx) {
+        mx.apply(_this, args);
       });
     }
   }
 }
 
 function wrapFunction(realMethod, mixins) {
-  const fn = function (...args) {
-    wrapper.call(this, realMethod, mixins, ...args);
+  var fn = function fn() {
+    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+      args[_key2] = arguments[_key2];
+    }
+
+    wrapper.call.apply(wrapper, [this, realMethod, mixins].concat(args));
   };
 
   return fn;
 }
 
 function patch(target, methodName, mixinMethod) {
-  const mixins = getMixins(target, methodName);
+  var mixins = getMixins(target, methodName);
 
   if (mixins.methods.indexOf(mixinMethod) < 0) {
     mixins.methods.push(mixinMethod);
   }
 
-  const oldDefinition = Object.getOwnPropertyDescriptor(target, methodName);
+  var oldDefinition = Object.getOwnPropertyDescriptor(target, methodName);
 
   if (oldDefinition && oldDefinition[mobxPatchedDefinition]) {
     // already patched definition, do not repatch
     return;
   }
 
-  const originalMethod = target[methodName];
-  const newDefinition = createDefinition(target, methodName, oldDefinition ? oldDefinition.enumerable : undefined, mixins, originalMethod);
+  var originalMethod = target[methodName];
+  var newDefinition = createDefinition(target, methodName, oldDefinition ? oldDefinition.enumerable : undefined, mixins, originalMethod);
   Object.defineProperty(target, methodName, newDefinition);
 }
 
 function createDefinition(target, methodName, enumerable, mixins, originalMethod) {
-  let wrappedFunc = wrapFunction(originalMethod, mixins);
-  return {
-    [mobxPatchedDefinition]: true,
-    get: function () {
-      return wrappedFunc;
-    },
-    set: function (value) {
-      if (this === target) {
-        wrappedFunc = wrapFunction(value, mixins);
-      } else {
-        // when it is an instance of the prototype/a child prototype patch that particular case again separately
-        // since we need to store separate values depending on wether it is the actual instance, the prototype, etc
-        // e.g. the method for super might not be the same as the method for the prototype which might be not the same
-        // as the method for the instance
-        const newDefinition = createDefinition(this, methodName, enumerable, mixins, value);
-        Object.defineProperty(this, methodName, newDefinition);
-      }
-    },
-    configurable: true,
-    enumerable: enumerable
-  };
+  var _ref;
+
+  var wrappedFunc = wrapFunction(originalMethod, mixins);
+  return _ref = {}, _ref[mobxPatchedDefinition] = true, _ref.get = function get() {
+    return wrappedFunc;
+  }, _ref.set = function set(value) {
+    if (this === target) {
+      wrappedFunc = wrapFunction(value, mixins);
+    } else {
+      // when it is an instance of the prototype/a child prototype patch that particular case again separately
+      // since we need to store separate values depending on wether it is the actual instance, the prototype, etc
+      // e.g. the method for super might not be the same as the method for the prototype which might be not the same
+      // as the method for the instance
+      var newDefinition = createDefinition(this, methodName, enumerable, mixins, value);
+      Object.defineProperty(this, methodName, newDefinition);
+    }
+  }, _ref.configurable = true, _ref.enumerable = enumerable, _ref;
 }
 
-const mobxAdminProperty = mobx.$mobx || "$mobx";
-const mobxIsUnmounted =
+var mobxAdminProperty = mobx.$mobx || "$mobx";
+var mobxIsUnmounted =
 /*#__PURE__*/
 newSymbol("isUnmounted");
-const skipRenderKey =
+var skipRenderKey =
 /*#__PURE__*/
 newSymbol("skipRender");
-const isForcingUpdateKey =
+var isForcingUpdateKey =
 /*#__PURE__*/
 newSymbol("isForcingUpdate");
 function makeClassComponentObserver(componentClass) {
-  const target = componentClass.prototype;
+  var target = componentClass.prototype;
   if (target.componentWillReact) throw new Error("The componentWillReact life-cycle event is no longer supported");
 
   if (componentClass["__proto__"] !== React.PureComponent) {
@@ -222,7 +228,7 @@ function makeClassComponentObserver(componentClass) {
 
   makeObservableProp(target, "props");
   makeObservableProp(target, "state");
-  const baseRender = target.render;
+  var baseRender = target.render;
 
   target.render = function () {
     return makeComponentReactive.call(this, baseRender);
@@ -234,8 +240,8 @@ function makeClassComponentObserver(componentClass) {
     if (this.render[mobxAdminProperty]) {
       this.render[mobxAdminProperty].dispose();
     } else {
-      const displayName = getDisplayName(this);
-      console.warn(`The render function for an observer component (${displayName}) was modified after MobX attached. This is not supported, since the new function can't be triggered by MobX.`);
+      var displayName = getDisplayName(this);
+      console.warn("The render function for an observer component (" + displayName + ") was modified after MobX attached. This is not supported, since the new function can't be triggered by MobX.");
     }
 
     this[mobxIsUnmounted] = true;
@@ -248,6 +254,8 @@ function getDisplayName(comp) {
 }
 
 function makeComponentReactive(render) {
+  var _this = this;
+
   if (mobxReactLite.isUsingStaticRendering() === true) return render.call(this);
   /**
    * If props are shallowly modified, react will render anyway,
@@ -261,25 +269,25 @@ function makeComponentReactive(render) {
    */
 
   setHiddenProp(this, isForcingUpdateKey, false);
-  const initialName = getDisplayName(this);
-  const baseRender = render.bind(this);
-  let isRenderingPending = false;
-  const reaction = new mobx.Reaction(`${initialName}.render()`, () => {
+  var initialName = getDisplayName(this);
+  var baseRender = render.bind(this);
+  var isRenderingPending = false;
+  var reaction = new mobx.Reaction(initialName + ".render()", function () {
     if (!isRenderingPending) {
       // N.B. Getting here *before mounting* means that a component constructor has side effects (see the relevant test in misc.js)
       // This unidiomatic React usage but React will correctly warn about this so we continue as usual
       // See #85 / Pull #44
       isRenderingPending = true;
 
-      if (this[mobxIsUnmounted] !== true) {
-        let hasError = true;
+      if (_this[mobxIsUnmounted] !== true) {
+        var hasError = true;
 
         try {
-          setHiddenProp(this, isForcingUpdateKey, true);
-          if (!this[skipRenderKey]) React.Component.prototype.forceUpdate.call(this);
+          setHiddenProp(_this, isForcingUpdateKey, true);
+          if (!_this[skipRenderKey]) React.Component.prototype.forceUpdate.call(_this);
           hasError = false;
         } finally {
-          setHiddenProp(this, isForcingUpdateKey, false);
+          setHiddenProp(_this, isForcingUpdateKey, false);
           if (hasError) reaction.dispose();
         }
       }
@@ -291,9 +299,9 @@ function makeComponentReactive(render) {
 
   function reactiveRender() {
     isRenderingPending = false;
-    let exception = undefined;
-    let rendering = undefined;
-    reaction.track(() => {
+    var exception = undefined;
+    var rendering = undefined;
+    reaction.track(function () {
       try {
         rendering = mobx._allowStateChanges(false, baseRender);
       } catch (e) {
@@ -329,8 +337,8 @@ function observerSCU(nextProps, nextState) {
 }
 
 function makeObservableProp(target, propName) {
-  const valueHolderKey = newSymbol(`reactProp_${propName}_valueHolder`);
-  const atomHolderKey = newSymbol(`reactProp_${propName}_atomHolder`);
+  var valueHolderKey = newSymbol("reactProp_" + propName + "_valueHolder");
+  var atomHolderKey = newSymbol("reactProp_" + propName + "_atomHolder");
 
   function getAtom() {
     if (!this[atomHolderKey]) {
@@ -343,8 +351,8 @@ function makeObservableProp(target, propName) {
   Object.defineProperty(target, propName, {
     configurable: true,
     enumerable: true,
-    get: function () {
-      let prevReadState = false;
+    get: function get() {
+      var prevReadState = false;
 
       if (mobx._allowStateReadsStart && mobx._allowStateReadsEnd) {
         prevReadState = mobx._allowStateReadsStart(true);
@@ -371,18 +379,22 @@ function makeObservableProp(target, propName) {
   });
 }
 
-const hasSymbol = typeof Symbol === "function" && Symbol.for; // Using react-is had some issues (and operates on elements, not on types), see #608 / #609
+var hasSymbol = typeof Symbol === "function" && Symbol.for; // Using react-is had some issues (and operates on elements, not on types), see #608 / #609
 
-const ReactForwardRefSymbol = hasSymbol ?
+var ReactForwardRefSymbol = hasSymbol ?
 /*#__PURE__*/
 Symbol.for("react.forward_ref") : typeof React.forwardRef === "function" &&
 /*#__PURE__*/
-React.forwardRef(props => null)["$$typeof"];
-const ReactMemoSymbol = hasSymbol ?
+React.forwardRef(function (props) {
+  return null;
+})["$$typeof"];
+var ReactMemoSymbol = hasSymbol ?
 /*#__PURE__*/
 Symbol.for("react.memo") : typeof React.memo === "function" &&
 /*#__PURE__*/
-React.memo(props => null)["$$typeof"];
+React.memo(function (props) {
+  return null;
+})["$$typeof"];
 /**
  * Observer function / decorator
  */
@@ -400,10 +412,13 @@ function observer(component) {
 
 
   if (ReactForwardRefSymbol && component["$$typeof"] === ReactForwardRefSymbol) {
-    const baseRender = component["render"];
+    var baseRender = component["render"];
     if (typeof baseRender !== "function") throw new Error("render property of ForwardRef was not a function");
     return React.forwardRef(function ObserverForwardRef() {
-      return React.createElement(mobxReactLite.Observer, null, () => baseRender.apply(undefined, arguments));
+      var args = arguments;
+      return React.createElement(mobxReactLite.Observer, null, function () {
+        return baseRender.apply(undefined, args);
+      });
     });
   } // Function component
 
@@ -415,24 +430,53 @@ function observer(component) {
   return makeClassComponentObserver(component);
 }
 
-const MobXProviderContext =
+function _extends() {
+  _extends = Object.assign || function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+
+    return target;
+  };
+
+  return _extends.apply(this, arguments);
+}
+
+function _objectWithoutPropertiesLoose(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;
+}
+
+var MobXProviderContext =
 /*#__PURE__*/
 React__default.createContext({});
 function Provider(props) {
-  const {
-    children,
-    ...stores
-  } = props;
-  const parentValue = React__default.useContext(MobXProviderContext);
-  const mutableProviderRef = React__default.useRef({ ...parentValue,
-    ...stores
-  });
-  const value = mutableProviderRef.current;
+  var children = props.children,
+      stores = _objectWithoutPropertiesLoose(props, ["children"]);
+
+  var parentValue = React__default.useContext(MobXProviderContext);
+  var mutableProviderRef = React__default.useRef(_extends({}, parentValue, {}, stores));
+  var value = mutableProviderRef.current;
 
   {
-    const newValue = { ...value,
-      ...stores
-    }; // spread in previous state for the context based stores
+    var newValue = _extends({}, value, {}, stores); // spread in previous state for the context based stores
+
 
     if (!shallowEqual(value, newValue)) {
       throw new Error("MobX Provider: The set of provided stores has changed. See: https://github.com/mobxjs/mobx-react#the-set-of-provided-stores-has-changed-error.");
@@ -451,10 +495,10 @@ Provider.displayName = "MobXProvider";
 
 function createStoreInjector(grabStoresFn, component, injectNames, makeReactive) {
   // Support forward refs
-  let Injector = React__default.forwardRef((props, ref) => {
-    const newProps = { ...props
-    };
-    const context = React__default.useContext(MobXProviderContext);
+  var Injector = React__default.forwardRef(function (props, ref) {
+    var newProps = _extends({}, props);
+
+    var context = React__default.useContext(MobXProviderContext);
     Object.assign(newProps, grabStoresFn(context || {}, newProps) || {});
 
     if (ref) {
@@ -474,8 +518,8 @@ function createStoreInjector(grabStoresFn, component, injectNames, makeReactive)
 }
 
 function getInjectName(component, injectNames) {
-  let displayName;
-  const componentName = component.displayName || component.name || component.constructor && component.constructor.name || "Component";
+  var displayName;
+  var componentName = component.displayName || component.name || component.constructor && component.constructor.name || "Component";
   if (injectNames) displayName = "inject-with-" + injectNames + "(" + componentName + ")";else displayName = "inject(" + componentName + ")";
   return displayName;
 }
@@ -499,41 +543,52 @@ function grabStoresByName(storeNames) {
  */
 
 
-function inject(
-/* fn(stores, nextProps) or ...storeNames */
-...storeNames) {
+function inject() {
+  for (var _len = arguments.length, storeNames = new Array(_len), _key = 0; _key < _len; _key++) {
+    storeNames[_key] = arguments[_key];
+  }
+
   if (typeof arguments[0] === "function") {
-    let grabStoresFn = arguments[0];
-    return componentClass => createStoreInjector(grabStoresFn, componentClass, grabStoresFn.name, true);
+    var grabStoresFn = arguments[0];
+    return function (componentClass) {
+      return createStoreInjector(grabStoresFn, componentClass, grabStoresFn.name, true);
+    };
   } else {
-    return componentClass => createStoreInjector(grabStoresByName(storeNames), componentClass, storeNames.join("-"), false);
+    return function (componentClass) {
+      return createStoreInjector(grabStoresByName(storeNames), componentClass, storeNames.join("-"), false);
+    };
   }
 }
 
-const protoStoreKey =
+var protoStoreKey =
 /*#__PURE__*/
 newSymbol("disposeOnUnmountProto");
-const instStoreKey =
+var instStoreKey =
 /*#__PURE__*/
 newSymbol("disposeOnUnmountInst");
 
 function runDisposersOnWillUnmount() {
-  [...(this[protoStoreKey] || []), ...(this[instStoreKey] || [])].forEach(propKeyOrFunction => {
-    const prop = typeof propKeyOrFunction === "string" ? this[propKeyOrFunction] : propKeyOrFunction;
+  var _this = this;
+  [].concat(this[protoStoreKey] || [], this[instStoreKey] || []).forEach(function (propKeyOrFunction) {
+    var prop = typeof propKeyOrFunction === "string" ? _this[propKeyOrFunction] : propKeyOrFunction;
 
     if (prop !== undefined && prop !== null) {
-      if (Array.isArray(prop)) prop.map(f => f());else prop();
+      if (Array.isArray(prop)) prop.map(function (f) {
+        return f();
+      });else prop();
     }
   });
 }
 
 function disposeOnUnmount(target, propertyKeyOrFunction) {
   if (Array.isArray(propertyKeyOrFunction)) {
-    return propertyKeyOrFunction.map(fn => disposeOnUnmount(target, fn));
+    return propertyKeyOrFunction.map(function (fn) {
+      return disposeOnUnmount(target, fn);
+    });
   }
 
-  const c = Object.getPrototypeOf(target).constructor || Object.getPrototypeOf(target.constructor);
-  const c2 = Object.getPrototypeOf(target.constructor);
+  var c = Object.getPrototypeOf(target).constructor || Object.getPrototypeOf(target.constructor);
+  var c2 = Object.getPrototypeOf(target.constructor);
 
   if (!(c === React__default.Component || c === React__default.PureComponent || c2 === React__default.Component || c2 === React__default.PureComponent)) {
     throw new Error("[mobx-react] disposeOnUnmount only supports direct subclasses of React.Component or React.PureComponent.");
@@ -544,10 +599,10 @@ function disposeOnUnmount(target, propertyKeyOrFunction) {
   } // decorator's target is the prototype, so it doesn't have any instance properties like props
 
 
-  const isDecorator = typeof propertyKeyOrFunction === "string"; // add property key / function we want run (disposed) to the store
+  var isDecorator = typeof propertyKeyOrFunction === "string"; // add property key / function we want run (disposed) to the store
 
-  const componentWasAlreadyModified = !!target[protoStoreKey] || !!target[instStoreKey];
-  const store = isDecorator ? // decorators are added to the prototype store
+  var componentWasAlreadyModified = !!target[protoStoreKey] || !!target[instStoreKey];
+  var store = isDecorator ? // decorators are added to the prototype store
   target[protoStoreKey] || (target[protoStoreKey] = []) : // functions are added to the instance store
   target[instStoreKey] || (target[instStoreKey] = []);
   store.push(propertyKeyOrFunction); // tweak the component class componentWillUnmount if not done already
@@ -563,26 +618,30 @@ function disposeOnUnmount(target, propertyKeyOrFunction) {
 }
 
 function createChainableTypeChecker(validator) {
-  function checkType(isRequired, props, propName, componentName, location, propFullName, ...rest) {
-    return mobx.untracked(() => {
+  function checkType(isRequired, props, propName, componentName, location, propFullName) {
+    for (var _len = arguments.length, rest = new Array(_len > 6 ? _len - 6 : 0), _key = 6; _key < _len; _key++) {
+      rest[_key - 6] = arguments[_key];
+    }
+
+    return mobx.untracked(function () {
       componentName = componentName || "<<anonymous>>";
       propFullName = propFullName || propName;
 
       if (props[propName] == null) {
         if (isRequired) {
-          const actual = props[propName] === null ? "null" : "undefined";
+          var actual = props[propName] === null ? "null" : "undefined";
           return new Error("The " + location + " `" + propFullName + "` is marked as required " + "in `" + componentName + "`, but its value is `" + actual + "`.");
         }
 
         return null;
       } else {
         // @ts-ignore rest arg is necessary for some React internals - fails tests otherwise
-        return validator(props, propName, componentName, location, propFullName, ...rest);
+        return validator.apply(void 0, [props, propName, componentName, location, propFullName].concat(rest));
       }
     });
   }
 
-  const chainedCheckType = checkType.bind(null, false); // Add isRequired to satisfy Requirable
+  var chainedCheckType = checkType.bind(null, false); // Add isRequired to satisfy Requirable
 
   chainedCheckType.isRequired = checkType.bind(null, true);
   return chainedCheckType;
@@ -610,7 +669,7 @@ function isSymbol(propType, propValue) {
 
 
 function getPropType(propValue) {
-  const propType = typeof propValue;
+  var propType = typeof propValue;
 
   if (Array.isArray(propValue)) {
     return "array";
@@ -633,7 +692,7 @@ function getPropType(propValue) {
 
 
 function getPreciseType(propValue) {
-  const propType = getPropType(propValue);
+  var propType = getPropType(propValue);
 
   if (propType === "object") {
     if (propValue instanceof Date) {
@@ -647,13 +706,13 @@ function getPreciseType(propValue) {
 }
 
 function createObservableTypeCheckerCreator(allowNativeType, mobxType) {
-  return createChainableTypeChecker((props, propName, componentName, location, propFullName) => {
-    return mobx.untracked(() => {
+  return createChainableTypeChecker(function (props, propName, componentName, location, propFullName) {
+    return mobx.untracked(function () {
       if (allowNativeType) {
         if (getPropType(props[propName]) === mobxType.toLowerCase()) return null;
       }
 
-      let mobxChecker;
+      var mobxChecker;
 
       switch (mobxType) {
         case "Array":
@@ -669,14 +728,14 @@ function createObservableTypeCheckerCreator(allowNativeType, mobxType) {
           break;
 
         default:
-          throw new Error(`Unexpected mobxType: ${mobxType}`);
+          throw new Error("Unexpected mobxType: " + mobxType);
       }
 
-      const propValue = props[propName];
+      var propValue = props[propName];
 
       if (!mobxChecker(propValue)) {
-        const preciseType = getPreciseType(propValue);
-        const nativeTypeExpectationMessage = allowNativeType ? " or javascript `" + mobxType.toLowerCase() + "`" : "";
+        var preciseType = getPreciseType(propValue);
+        var nativeTypeExpectationMessage = allowNativeType ? " or javascript `" + mobxType.toLowerCase() + "`" : "";
         return new Error("Invalid prop `" + propFullName + "` of type `" + preciseType + "` supplied to" + " `" + componentName + "`, expected `mobx.Observable" + mobxType + "`" + nativeTypeExpectationMessage + ".");
       }
 
@@ -686,17 +745,21 @@ function createObservableTypeCheckerCreator(allowNativeType, mobxType) {
 }
 
 function createObservableArrayOfTypeChecker(allowNativeType, typeChecker) {
-  return createChainableTypeChecker((props, propName, componentName, location, propFullName, ...rest) => {
-    return mobx.untracked(() => {
+  return createChainableTypeChecker(function (props, propName, componentName, location, propFullName) {
+    for (var _len2 = arguments.length, rest = new Array(_len2 > 5 ? _len2 - 5 : 0), _key2 = 5; _key2 < _len2; _key2++) {
+      rest[_key2 - 5] = arguments[_key2];
+    }
+
+    return mobx.untracked(function () {
       if (typeof typeChecker !== "function") {
         return new Error("Property `" + propFullName + "` of component `" + componentName + "` has " + "invalid PropType notation.");
       } else {
-        let error = createObservableTypeCheckerCreator(allowNativeType, "Array")(props, propName, componentName, location, propFullName);
+        var error = createObservableTypeCheckerCreator(allowNativeType, "Array")(props, propName, componentName, location, propFullName);
         if (error instanceof Error) return error;
-        const propValue = props[propName];
+        var propValue = props[propName];
 
-        for (let i = 0; i < propValue.length; i++) {
-          error = typeChecker(propValue, i, componentName, location, propFullName + "[" + i + "]", ...rest);
+        for (var i = 0; i < propValue.length; i++) {
+          error = typeChecker.apply(void 0, [propValue, i, componentName, location, propFullName + "[" + i + "]"].concat(rest));
           if (error instanceof Error) return error;
         }
 
@@ -706,35 +769,35 @@ function createObservableArrayOfTypeChecker(allowNativeType, typeChecker) {
   });
 }
 
-const observableArray =
+var observableArray =
 /*#__PURE__*/
 createObservableTypeCheckerCreator(false, "Array");
-const observableArrayOf =
+var observableArrayOf =
 /*#__PURE__*/
 createObservableArrayOfTypeChecker.bind(null, false);
-const observableMap =
+var observableMap =
 /*#__PURE__*/
 createObservableTypeCheckerCreator(false, "Map");
-const observableObject =
+var observableObject =
 /*#__PURE__*/
 createObservableTypeCheckerCreator(false, "Object");
-const arrayOrObservableArray =
+var arrayOrObservableArray =
 /*#__PURE__*/
 createObservableTypeCheckerCreator(true, "Array");
-const arrayOrObservableArrayOf =
+var arrayOrObservableArrayOf =
 /*#__PURE__*/
 createObservableArrayOfTypeChecker.bind(null, true);
-const objectOrObservableObject =
+var objectOrObservableObject =
 /*#__PURE__*/
 createObservableTypeCheckerCreator(true, "Object");
-const PropTypes = {
-  observableArray,
-  observableArrayOf,
-  observableMap,
-  observableObject,
-  arrayOrObservableArray,
-  arrayOrObservableArrayOf,
-  objectOrObservableObject
+var PropTypes = {
+  observableArray: observableArray,
+  observableArrayOf: observableArrayOf,
+  observableMap: observableMap,
+  observableObject: observableObject,
+  arrayOrObservableArray: arrayOrObservableArray,
+  arrayOrObservableArrayOf: arrayOrObservableArrayOf,
+  objectOrObservableObject: objectOrObservableObject
 };
 
 if (!React.Component) throw new Error("mobx-react requires React to be available");