* react-dom.development.js

 *

 * Copyright (c) Facebook, Inc. and its affiliates.

 *

 * This source code is licensed under the MIT license found in the

 * LICENSE file in the root directory of this source tree.

 */

'use strict';

(function (global, factory) {

	typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('react')) :

	typeof define === 'function' && define.amd ? define(['react'], factory) :

	(global.ReactDOM = factory(global.React));

}(this, (function (React) { 'use strict';

/**

 * Use invariant() to assert state which your program assumes to be true.

 *

 * Provide sprintf-style format (only %s is supported) and arguments

 * to provide information about what broke and what you were

 * expecting.

 *

 * The invariant message will be stripped in production, but the invariant

 * will remain to ensure logic does not differ in production.

 */

var invokeGuardedCallbackImpl = function (name, func, context, a, b, c, d, e, f) {

  var funcArgs = Array.prototype.slice.call(arguments, 3);

  try {

    func.apply(context, funcArgs);

  } catch (error) {

    this.onError(error);

  }

};

{

  // In DEV mode, we swap out invokeGuardedCallback for a special version

  // that plays more nicely with the browser's DevTools. The idea is to preserve

  // "Pause on exceptions" behavior. Because React wraps all user-provided

  // functions in invokeGuardedCallback, and the production version of

  // invokeGuardedCallback uses a try-catch, all user exceptions are treated

  // like caught exceptions, and the DevTools won't pause unless the developer

  // takes the extra step of enabling pause on caught exceptions. This is

  // unintuitive, though, because even though React has caught the error, from

  // the developer's perspective, the error is uncaught.

  //

  // To preserve the expected "Pause on exceptions" behavior, we don't use a

  // try-catch in DEV. Instead, we synchronously dispatch a fake event to a fake

  // DOM node, and call the user-provided callback from inside an event handler

  // for that fake event. If the callback throws, the error is "captured" using

  // a global event handler. But because the error happens in a different

  // event loop context, it does not interrupt the normal program flow.

  // Effectively, this gives us try-catch behavior without actually using

  // try-catch. Neat!

  // Check that the browser supports the APIs we need to implement our special

  // DEV version of invokeGuardedCallback

  if (typeof window !== 'undefined' && typeof window.dispatchEvent === 'function' && typeof document !== 'undefined' && typeof document.createEvent === 'function') {

    var fakeNode = document.createElement('react');

    var invokeGuardedCallbackDev = function (name, func, context, a, b, c, d, e, f) {

      // If document doesn't exist we know for sure we will crash in this method

      // when we call document.createEvent(). However this can cause confusing

      // errors: https://github.com/facebookincubator/create-react-app/issues/3482

      // So we preemptively throw with a better message instead.

      var evt = document.createEvent('Event');

      // Keeps track of whether the user-provided callback threw an error. We

      // set this to true at the beginning, then set it to false right after

      // calling the function. If the function errors, `didError` will never be

      // set to false. This strategy works even if the browser is flaky and

      // fails to call our global error handler, because it doesn't rely on

      // the error event at all.

      var didError = true;

      // Keeps track of the value of window.event so that we can reset it

      // during the callback to let user code access window.event in the

      // browsers that support it.

      var windowEvent = window.event;

      // Keeps track of the descriptor of window.event to restore it after event

      // dispatching: https://github.com/facebook/react/issues/13688

      var windowEventDescriptor = Object.getOwnPropertyDescriptor(window, 'event');

      // Create an event handler for our fake event. We will synchronously

      // dispatch our fake event using `dispatchEvent`. Inside the handler, we

      // call the user-provided callback.

      var funcArgs = Array.prototype.slice.call(arguments, 3);

      function callCallback() {

        // We immediately remove the callback from event listeners so that

        // nested `invokeGuardedCallback` calls do not clash. Otherwise, a

        // nested call would trigger the fake event handlers of any call higher

        // in the stack.

        fakeNode.removeEventListener(evtType, callCallback, false);

        // We check for window.hasOwnProperty('event') to prevent the

        // window.event assignment in both IE <= 10 as they throw an error

        // "Member not found" in strict mode, and in Firefox which does not

        // support window.event.

        if (typeof window.event !== 'undefined' && window.hasOwnProperty('event')) {

          window.event = windowEvent;

        }

        func.apply(context, funcArgs);

        didError = false;

      }

      // Create a global error event handler. We use this to capture the value

      // that was thrown. It's possible that this error handler will fire more

      // than once; for example, if non-React code also calls `dispatchEvent`

      // and a handler for that event throws. We should be resilient to most of

      // those cases. Even if our error event handler fires more than once, the

      // last error event is always used. If the callback actually does error,

      // we know that the last error event is the correct one, because it's not

      // possible for anything else to have happened in between our callback

      // erroring and the code that follows the `dispatchEvent` call below. If

      // the callback doesn't error, but the error event was fired, we know to

      // ignore it because `didError` will be false, as described above.

      var error = void 0;

      // Use this to track whether the error event is ever called.

      var didSetError = false;

      var isCrossOriginError = false;

      function handleWindowError(event) {

        error = event.error;

        didSetError = true;

        if (error === null && event.colno === 0 && event.lineno === 0) {

          isCrossOriginError = true;

        }

        if (event.defaultPrevented) {

          // Some other error handler has prevented default.

          // Browsers silence the error report if this happens.

          // We'll remember this to later decide whether to log it or not.

          if (error != null && typeof error === 'object') {

            try {

              error._suppressLogging = true;

            } catch (inner) {

              // Ignore.

            }

          }

        }

      }

      // Create a fake event type.

      var evtType = 'react-' + (name ? name : 'invokeguardedcallback');

      // Attach our event handlers

      window.addEventListener('error', handleWindowError);

      fakeNode.addEventListener(evtType, callCallback, false);

      // Synchronously dispatch our fake event. If the user-provided function

      // errors, it will trigger our global error handler.

      evt.initEvent(evtType, false, false);

      fakeNode.dispatchEvent(evt);

      if (windowEventDescriptor) {

        Object.defineProperty(window, 'event', windowEventDescriptor);

      }

      if (didError) {

        if (!didSetError) {

          // The callback errored, but the error event never fired.

          error = new Error('An error was thrown inside one of your components, but React ' + "doesn't know what it was. This is likely due to browser " + 'flakiness. React does its best to preserve the "Pause on ' + 'exceptions" behavior of the DevTools, which requires some ' + "DEV-mode only tricks. It's possible that these don't work in " + 'your browser. Try triggering the error in production mode, ' + 'or switching to a modern browser. If you suspect that this is ' + 'actually an issue with React, please file an issue.');

        } else if (isCrossOriginError) {

          error = new Error("A cross-origin error was thrown. React doesn't have access to " + 'the actual error object in development. ' + 'See https://fb.me/react-crossorigin-error for more information.');

        }

        this.onError(error);

      }

      // Remove our event listeners

      window.removeEventListener('error', handleWindowError);

    };

    invokeGuardedCallbackImpl = invokeGuardedCallbackDev;

  }

}

var invokeGuardedCallbackImpl$1 = invokeGuardedCallbackImpl;

// Used by Fiber to simulate a try-catch.

var hasError = false;

var caughtError = null;

// Used by event system to capture/rethrow the first error.

var hasRethrowError = false;

var rethrowError = null;

var reporter = {

  onError: function (error) {

    hasError = true;

    caughtError = error;

  }

};

/**

 * Call a function while guarding against errors that happens within it.

 * Returns an error if it throws, otherwise null.

 *

 * In production, this is implemented using a try-catch. The reason we don't

 * use a try-catch directly is so that we can swap out a different

 * implementation in DEV mode.

 *

 * @param {String} name of the guard to use for logging or debugging

 * @param {Function} func The function to invoke

 * @param {*} context The context to use when calling the function

 * @param {...*} args Arguments for function

 */

function invokeGuardedCallback(name, func, context, a, b, c, d, e, f) {

  hasError = false;

  caughtError = null;

  invokeGuardedCallbackImpl$1.apply(reporter, arguments);

}

/**

 * Same as invokeGuardedCallback, but instead of returning an error, it stores

 * it in a global so it can be rethrown by `rethrowCaughtError` later.

 * TODO: See if caughtError and rethrowError can be unified.

 *

 * @param {String} name of the guard to use for logging or debugging

 * @param {Function} func The function to invoke

 * @param {*} context The context to use when calling the function

 * @param {...*} args Arguments for function

 */

function invokeGuardedCallbackAndCatchFirstError(name, func, context, a, b, c, d, e, f) {

  invokeGuardedCallback.apply(this, arguments);

  if (hasError) {

    var error = clearCaughtError();

    if (!hasRethrowError) {

      hasRethrowError = true;

      rethrowError = error;

    }

  }

}

/**

 * During execution of guarded functions we will capture the first error which

 * we will rethrow to be handled by the top level error handler.

 */

function rethrowCaughtError() {

  if (hasRethrowError) {

    var error = rethrowError;

    hasRethrowError = false;

    rethrowError = null;

    throw error;

  }

}

function hasCaughtError() {

  return hasError;

}

function clearCaughtError() {

  if (hasError) {

    var error = caughtError;

    hasError = false;

    caughtError = null;

    return error;

  } else {

  }

}

/**

 * Similar to invariant but only logs a warning if the condition is not met.

 * This can be used to log issues in development environments in critical

 * paths. Removing the logging code for production environments will keep the

 * same logic and follow the same code paths.

 */