mobx-react 6.1.7 → 6.1.8

package/dist/mobxreact.umd.development.js

@@ -6,19 +6,19 @@
 
     var React__default = 'default' in React ? React['default'] : React;
 
-    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);
@@ -34,11 +34,11 @@
         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;
         }
@@ -57,7 +57,7 @@
     } // 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,
@@ -73,8 +73,8 @@
       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));
         }
@@ -93,7 +93,7 @@
           enumerable: false,
           configurable: true,
           writable: true,
-          value
+          value: value
         });
       } else {
         target[prop] = value;
@@ -104,27 +104,33 @@
      * 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);
@@ -135,76 +141,76 @@
         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) {
@@ -218,7 +224,7 @@
 
       makeObservableProp(target, "props");
       makeObservableProp(target, "state");
-      const baseRender = target.render;
+      var baseRender = target.render;
 
       target.render = function () {
         return makeComponentReactive.call(this, baseRender);
@@ -230,8 +236,8 @@
         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;
@@ -244,6 +250,8 @@
     }
 
     function makeComponentReactive(render) {
+      var _this = this;
+
       if (mobxReactLite.isUsingStaticRendering() === true) return render.call(this);
       /**
        * If props are shallowly modified, react will render anyway,
@@ -257,25 +265,25 @@
        */
 
       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();
             }
           }
@@ -287,9 +295,9 @@
 
       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) {
@@ -325,8 +333,8 @@
     }
 
     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]) {
@@ -339,8 +347,8 @@
       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);
@@ -367,18 +375,22 @@
       });
     }
 
-    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
      */
@@ -396,10 +408,13 @@
 
 
       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
 
@@ -411,24 +426,53 @@
       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.");
@@ -447,10 +491,10 @@
 
     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) {
@@ -470,8 +514,8 @@
     }
 
     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;
     }
@@ -495,41 +539,52 @@
      */
 
 
-    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.");
@@ -540,10 +595,10 @@
       } // 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
@@ -559,26 +614,30 @@
     }
 
     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;
@@ -606,7 +665,7 @@
 
 
     function getPropType(propValue) {
-      const propType = typeof propValue;
+      var propType = typeof propValue;
 
       if (Array.isArray(propValue)) {
         return "array";
@@ -629,7 +688,7 @@
 
 
     function getPreciseType(propValue) {
-      const propType = getPropType(propValue);
+      var propType = getPropType(propValue);
 
       if (propType === "object") {
         if (propValue instanceof Date) {
@@ -643,13 +702,13 @@
     }
 
     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":
@@ -665,14 +724,14 @@
               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 + ".");
           }
 
@@ -682,17 +741,21 @@
     }
 
     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;
             }
 
@@ -702,35 +765,35 @@
       });
     }
 
-    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");