{"version":3,"sources":["node_modules\\react-dom\\lib\\ReactMount.js"],"names":["_prodInvariant","require","DOMLazyTree","DOMProperty","React","ReactBrowserEventEmitter","ReactCurrentOwner","ReactDOMComponentTree","ReactDOMContainerInfo","ReactDOMFeatureFlags","ReactFeatureFlags","ReactInstanceMap","ReactInstrumentation","ReactMarkupChecksum","ReactReconciler","ReactUpdateQueue","ReactUpdates","emptyObject","instantiateReactComponent","invariant","setInnerHTML","shouldUpdateReactComponent","warning","ATTR_NAME","ID_ATTRIBUTE_NAME","ROOT_ATTR_NAME","ROOT_ATTRIBUTE_NAME","ELEMENT_NODE_TYPE","DOC_NODE_TYPE","DOCUMENT_FRAGMENT_NODE_TYPE","instancesByReactRootID","firstDifferenceIndex","string1","string2","minLen","Math","min","length","i","charAt","getReactRootElementInContainer","container","nodeType","documentElement","firstChild","internalGetID","node","getAttribute","mountComponentIntoNode","wrapperInstance","transaction","shouldReuseMarkup","context","markerName","logTopLevelRenders","wrappedElement","_currentElement","props","child","type","displayName","name","console","time","markup","mountComponent","timeEnd","_renderedComponent","_topLevelWrapper","ReactMount","_mountImageIntoNode","batchedMountComponentIntoNode","componentInstance","ReactReconcileTransaction","getPooled","useCreateElement","perform","release","unmountComponentFromNode","instance","safely","process","env","NODE_ENV","debugTool","onBeginFlush","unmountComponent","onEndFlush","lastChild","removeChild","hasNonRootReactChild","rootEl","inst","getInstanceFromNode","_hostParent","nodeIsRenderedByOtherInstance","isReactNode","isValidContainer","hasAttribute","getHostRootInstanceInContainer","prevHostInstance","getTopLevelWrapperInContainer","root","_hostContainerInfo","topLevelRootCounter","TopLevelWrapper","rootID","prototype","isReactComponent","render","isReactTopLevelWrapper","_instancesByReactRootID","scrollMonitor","renderCallback","_updateRootComponent","prevComponent","nextElement","nextContext","callback","enqueueElementInternal","enqueueCallbackInternal","_renderNewRootComponent","current","getName","ensureScrollValueMonitoring","batchedUpdates","wrapperID","_instance","renderSubtreeIntoContainer","parentComponent","has","_renderSubtreeIntoContainer","validateCallback","isValidElement","undefined","tagName","toUpperCase","nextWrappedElement","createElement","parentInst","get","_processChildContext","_context","prevWrappedElement","prevElement","publicInst","getPublicInstance","updatedCallback","call","unmountComponentAtNode","reactRootElement","containerHasReactMarkup","containerHasNonRootReactChild","nextSibling","rootElementSibling","component","isContainerReactRoot","rootElement","canReuseMarkup","precacheNode","checksum","CHECKSUM_ATTR_NAME","removeAttribute","rootMarkup","outerHTML","setAttribute","normalizedMarkup","normalizer","document","innerHTML","body","appendChild","contentDocument","write","diffIndex","difference","substring","insertTreeBefore","hostNode","_debugID","onHostOperation","instanceID","payload","toString","module","exports"],"mappings":"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","file":"ReactMount.js","sourceRoot":"d:/Work/Office/react-native-on-web/cli/tmpl/project","sourcesContent":["/**\n * Copyright 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n */\n\n'use strict';\n\nvar _prodInvariant = require('./reactProdInvariant');\n\nvar DOMLazyTree = require('./DOMLazyTree');\nvar DOMProperty = require('./DOMProperty');\nvar React = require('react/lib/React');\nvar ReactBrowserEventEmitter = require('./ReactBrowserEventEmitter');\nvar ReactCurrentOwner = require('react/lib/ReactCurrentOwner');\nvar ReactDOMComponentTree = require('./ReactDOMComponentTree');\nvar ReactDOMContainerInfo = require('./ReactDOMContainerInfo');\nvar ReactDOMFeatureFlags = require('./ReactDOMFeatureFlags');\nvar ReactFeatureFlags = require('./ReactFeatureFlags');\nvar ReactInstanceMap = require('./ReactInstanceMap');\nvar ReactInstrumentation = require('./ReactInstrumentation');\nvar ReactMarkupChecksum = require('./ReactMarkupChecksum');\nvar ReactReconciler = require('./ReactReconciler');\nvar ReactUpdateQueue = require('./ReactUpdateQueue');\nvar ReactUpdates = require('./ReactUpdates');\n\nvar emptyObject = require('fbjs/lib/emptyObject');\nvar instantiateReactComponent = require('./instantiateReactComponent');\nvar invariant = require('fbjs/lib/invariant');\nvar setInnerHTML = require('./setInnerHTML');\nvar shouldUpdateReactComponent = require('./shouldUpdateReactComponent');\nvar warning = require('fbjs/lib/warning');\n\nvar ATTR_NAME = DOMProperty.ID_ATTRIBUTE_NAME;\nvar ROOT_ATTR_NAME = DOMProperty.ROOT_ATTRIBUTE_NAME;\n\nvar ELEMENT_NODE_TYPE = 1;\nvar DOC_NODE_TYPE = 9;\nvar DOCUMENT_FRAGMENT_NODE_TYPE = 11;\n\nvar instancesByReactRootID = {};\n\n/**\n * Finds the index of the first character\n * that's not common between the two given strings.\n *\n * @return {number} the index of the character where the strings diverge\n */\nfunction firstDifferenceIndex(string1, string2) {\n  var minLen = Math.min(string1.length, string2.length);\n  for (var i = 0; i < minLen; i++) {\n    if (string1.charAt(i) !== string2.charAt(i)) {\n      return i;\n    }\n  }\n  return string1.length === string2.length ? -1 : minLen;\n}\n\n/**\n * @param {DOMElement|DOMDocument} container DOM element that may contain\n * a React component\n * @return {?*} DOM element that may have the reactRoot ID, or null.\n */\nfunction getReactRootElementInContainer(container) {\n  if (!container) {\n    return null;\n  }\n\n  if (container.nodeType === DOC_NODE_TYPE) {\n    return container.documentElement;\n  } else {\n    return container.firstChild;\n  }\n}\n\nfunction internalGetID(node) {\n  // If node is something like a window, document, or text node, none of\n  // which support attributes or a .getAttribute method, gracefully return\n  // the empty string, as if the attribute were missing.\n  return node.getAttribute && node.getAttribute(ATTR_NAME) || '';\n}\n\n/**\n * Mounts this component and inserts it into the DOM.\n *\n * @param {ReactComponent} componentInstance The instance to mount.\n * @param {DOMElement} container DOM element to mount into.\n * @param {ReactReconcileTransaction} transaction\n * @param {boolean} shouldReuseMarkup If true, do not insert markup\n */\nfunction mountComponentIntoNode(wrapperInstance, container, transaction, shouldReuseMarkup, context) {\n  var markerName;\n  if (ReactFeatureFlags.logTopLevelRenders) {\n    var wrappedElement = wrapperInstance._currentElement.props.child;\n    var type = wrappedElement.type;\n    markerName = 'React mount: ' + (typeof type === 'string' ? type : type.displayName || type.name);\n    console.time(markerName);\n  }\n\n  var markup = ReactReconciler.mountComponent(wrapperInstance, transaction, null, ReactDOMContainerInfo(wrapperInstance, container), context, 0 /* parentDebugID */\n  );\n\n  if (markerName) {\n    console.timeEnd(markerName);\n  }\n\n  wrapperInstance._renderedComponent._topLevelWrapper = wrapperInstance;\n  ReactMount._mountImageIntoNode(markup, container, wrapperInstance, shouldReuseMarkup, transaction);\n}\n\n/**\n * Batched mount.\n *\n * @param {ReactComponent} componentInstance The instance to mount.\n * @param {DOMElement} container DOM element to mount into.\n * @param {boolean} shouldReuseMarkup If true, do not insert markup\n */\nfunction batchedMountComponentIntoNode(componentInstance, container, shouldReuseMarkup, context) {\n  var transaction = ReactUpdates.ReactReconcileTransaction.getPooled(\n  /* useCreateElement */\n  !shouldReuseMarkup && ReactDOMFeatureFlags.useCreateElement);\n  transaction.perform(mountComponentIntoNode, null, componentInstance, container, transaction, shouldReuseMarkup, context);\n  ReactUpdates.ReactReconcileTransaction.release(transaction);\n}\n\n/**\n * Unmounts a component and removes it from the DOM.\n *\n * @param {ReactComponent} instance React component instance.\n * @param {DOMElement} container DOM element to unmount from.\n * @final\n * @internal\n * @see {ReactMount.unmountComponentAtNode}\n */\nfunction unmountComponentFromNode(instance, container, safely) {\n  if (process.env.NODE_ENV !== 'production') {\n    ReactInstrumentation.debugTool.onBeginFlush();\n  }\n  ReactReconciler.unmountComponent(instance, safely);\n  if (process.env.NODE_ENV !== 'production') {\n    ReactInstrumentation.debugTool.onEndFlush();\n  }\n\n  if (container.nodeType === DOC_NODE_TYPE) {\n    container = container.documentElement;\n  }\n\n  // http://jsperf.com/emptying-a-node\n  while (container.lastChild) {\n    container.removeChild(container.lastChild);\n  }\n}\n\n/**\n * True if the supplied DOM node has a direct React-rendered child that is\n * not a React root element. Useful for warning in `render`,\n * `unmountComponentAtNode`, etc.\n *\n * @param {?DOMElement} node The candidate DOM node.\n * @return {boolean} True if the DOM element contains a direct child that was\n * rendered by React but is not a root element.\n * @internal\n */\nfunction hasNonRootReactChild(container) {\n  var rootEl = getReactRootElementInContainer(container);\n  if (rootEl) {\n    var inst = ReactDOMComponentTree.getInstanceFromNode(rootEl);\n    return !!(inst && inst._hostParent);\n  }\n}\n\n/**\n * True if the supplied DOM node is a React DOM element and\n * it has been rendered by another copy of React.\n *\n * @param {?DOMElement} node The candidate DOM node.\n * @return {boolean} True if the DOM has been rendered by another copy of React\n * @internal\n */\nfunction nodeIsRenderedByOtherInstance(container) {\n  var rootEl = getReactRootElementInContainer(container);\n  return !!(rootEl && isReactNode(rootEl) && !ReactDOMComponentTree.getInstanceFromNode(rootEl));\n}\n\n/**\n * True if the supplied DOM node is a valid node element.\n *\n * @param {?DOMElement} node The candidate DOM node.\n * @return {boolean} True if the DOM is a valid DOM node.\n * @internal\n */\nfunction isValidContainer(node) {\n  return !!(node && (node.nodeType === ELEMENT_NODE_TYPE || node.nodeType === DOC_NODE_TYPE || node.nodeType === DOCUMENT_FRAGMENT_NODE_TYPE));\n}\n\n/**\n * True if the supplied DOM node is a valid React node element.\n *\n * @param {?DOMElement} node The candidate DOM node.\n * @return {boolean} True if the DOM is a valid React DOM node.\n * @internal\n */\nfunction isReactNode(node) {\n  return isValidContainer(node) && (node.hasAttribute(ROOT_ATTR_NAME) || node.hasAttribute(ATTR_NAME));\n}\n\nfunction getHostRootInstanceInContainer(container) {\n  var rootEl = getReactRootElementInContainer(container);\n  var prevHostInstance = rootEl && ReactDOMComponentTree.getInstanceFromNode(rootEl);\n  return prevHostInstance && !prevHostInstance._hostParent ? prevHostInstance : null;\n}\n\nfunction getTopLevelWrapperInContainer(container) {\n  var root = getHostRootInstanceInContainer(container);\n  return root ? root._hostContainerInfo._topLevelWrapper : null;\n}\n\n/**\n * Temporary (?) hack so that we can store all top-level pending updates on\n * composites instead of having to worry about different types of components\n * here.\n */\nvar topLevelRootCounter = 1;\nvar TopLevelWrapper = function () {\n  this.rootID = topLevelRootCounter++;\n};\nTopLevelWrapper.prototype.isReactComponent = {};\nif (process.env.NODE_ENV !== 'production') {\n  TopLevelWrapper.displayName = 'TopLevelWrapper';\n}\nTopLevelWrapper.prototype.render = function () {\n  return this.props.child;\n};\nTopLevelWrapper.isReactTopLevelWrapper = true;\n\n/**\n * Mounting is the process of initializing a React component by creating its\n * representative DOM elements and inserting them into a supplied `container`.\n * Any prior content inside `container` is destroyed in the process.\n *\n *   ReactMount.render(\n *     component,\n *     document.getElementById('container')\n *   );\n *\n *   <div id=\"container\">                   <-- Supplied `container`.\n *     <div data-reactid=\".3\">              <-- Rendered reactRoot of React\n *       // ...                                 component.\n *     </div>\n *   </div>\n *\n * Inside of `container`, the first element rendered is the \"reactRoot\".\n */\nvar ReactMount = {\n  TopLevelWrapper: TopLevelWrapper,\n\n  /**\n   * Used by devtools. The keys are not important.\n   */\n  _instancesByReactRootID: instancesByReactRootID,\n\n  /**\n   * This is a hook provided to support rendering React components while\n   * ensuring that the apparent scroll position of its `container` does not\n   * change.\n   *\n   * @param {DOMElement} container The `container` being rendered into.\n   * @param {function} renderCallback This must be called once to do the render.\n   */\n  scrollMonitor: function (container, renderCallback) {\n    renderCallback();\n  },\n\n  /**\n   * Take a component that's already mounted into the DOM and replace its props\n   * @param {ReactComponent} prevComponent component instance already in the DOM\n   * @param {ReactElement} nextElement component instance to render\n   * @param {DOMElement} container container to render into\n   * @param {?function} callback function triggered on completion\n   */\n  _updateRootComponent: function (prevComponent, nextElement, nextContext, container, callback) {\n    ReactMount.scrollMonitor(container, function () {\n      ReactUpdateQueue.enqueueElementInternal(prevComponent, nextElement, nextContext);\n      if (callback) {\n        ReactUpdateQueue.enqueueCallbackInternal(prevComponent, callback);\n      }\n    });\n\n    return prevComponent;\n  },\n\n  /**\n   * Render a new component into the DOM. Hooked by hooks!\n   *\n   * @param {ReactElement} nextElement element to render\n   * @param {DOMElement} container container to render into\n   * @param {boolean} shouldReuseMarkup if we should skip the markup insertion\n   * @return {ReactComponent} nextComponent\n   */\n  _renderNewRootComponent: function (nextElement, container, shouldReuseMarkup, context) {\n    // Various parts of our code (such as ReactCompositeComponent's\n    // _renderValidatedComponent) assume that calls to render aren't nested;\n    // verify that that's the case.\n    process.env.NODE_ENV !== 'production' ? warning(ReactCurrentOwner.current == null, '_renderNewRootComponent(): Render methods should be a pure function ' + 'of props and state; triggering nested component updates from ' + 'render is not allowed. If necessary, trigger nested updates in ' + 'componentDidUpdate. Check the render method of %s.', ReactCurrentOwner.current && ReactCurrentOwner.current.getName() || 'ReactCompositeComponent') : void 0;\n\n    !isValidContainer(container) ? process.env.NODE_ENV !== 'production' ? invariant(false, '_registerComponent(...): Target container is not a DOM element.') : _prodInvariant('37') : void 0;\n\n    ReactBrowserEventEmitter.ensureScrollValueMonitoring();\n    var componentInstance = instantiateReactComponent(nextElement, false);\n\n    // The initial render is synchronous but any updates that happen during\n    // rendering, in componentWillMount or componentDidMount, will be batched\n    // according to the current batching strategy.\n\n    ReactUpdates.batchedUpdates(batchedMountComponentIntoNode, componentInstance, container, shouldReuseMarkup, context);\n\n    var wrapperID = componentInstance._instance.rootID;\n    instancesByReactRootID[wrapperID] = componentInstance;\n\n    return componentInstance;\n  },\n\n  /**\n   * Renders a React component into the DOM in the supplied `container`.\n   *\n   * If the React component was previously rendered into `container`, this will\n   * perform an update on it and only mutate the DOM as necessary to reflect the\n   * latest React component.\n   *\n   * @param {ReactComponent} parentComponent The conceptual parent of this render tree.\n   * @param {ReactElement} nextElement Component element to render.\n   * @param {DOMElement} container DOM element to render into.\n   * @param {?function} callback function triggered on completion\n   * @return {ReactComponent} Component instance rendered in `container`.\n   */\n  renderSubtreeIntoContainer: function (parentComponent, nextElement, container, callback) {\n    !(parentComponent != null && ReactInstanceMap.has(parentComponent)) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'parentComponent must be a valid React Component') : _prodInvariant('38') : void 0;\n    return ReactMount._renderSubtreeIntoContainer(parentComponent, nextElement, container, callback);\n  },\n\n  _renderSubtreeIntoContainer: function (parentComponent, nextElement, container, callback) {\n    ReactUpdateQueue.validateCallback(callback, 'ReactDOM.render');\n    !React.isValidElement(nextElement) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactDOM.render(): Invalid component element.%s', typeof nextElement === 'string' ? \" Instead of passing a string like 'div', pass \" + \"React.createElement('div') or <div />.\" : typeof nextElement === 'function' ? ' Instead of passing a class like Foo, pass ' + 'React.createElement(Foo) or <Foo />.' : // Check if it quacks like an element\n    nextElement != null && nextElement.props !== undefined ? ' This may be caused by unintentionally loading two independent ' + 'copies of React.' : '') : _prodInvariant('39', typeof nextElement === 'string' ? \" Instead of passing a string like 'div', pass \" + \"React.createElement('div') or <div />.\" : typeof nextElement === 'function' ? ' Instead of passing a class like Foo, pass ' + 'React.createElement(Foo) or <Foo />.' : nextElement != null && nextElement.props !== undefined ? ' This may be caused by unintentionally loading two independent ' + 'copies of React.' : '') : void 0;\n\n    process.env.NODE_ENV !== 'production' ? warning(!container || !container.tagName || container.tagName.toUpperCase() !== 'BODY', 'render(): Rendering components directly into document.body is ' + 'discouraged, since its children are often manipulated by third-party ' + 'scripts and browser extensions. This may lead to subtle ' + 'reconciliation issues. Try rendering into a container element created ' + 'for your app.') : void 0;\n\n    var nextWrappedElement = React.createElement(TopLevelWrapper, {\n      child: nextElement\n    });\n\n    var nextContext;\n    if (parentComponent) {\n      var parentInst = ReactInstanceMap.get(parentComponent);\n      nextContext = parentInst._processChildContext(parentInst._context);\n    } else {\n      nextContext = emptyObject;\n    }\n\n    var prevComponent = getTopLevelWrapperInContainer(container);\n\n    if (prevComponent) {\n      var prevWrappedElement = prevComponent._currentElement;\n      var prevElement = prevWrappedElement.props.child;\n      if (shouldUpdateReactComponent(prevElement, nextElement)) {\n        var publicInst = prevComponent._renderedComponent.getPublicInstance();\n        var updatedCallback = callback && function () {\n          callback.call(publicInst);\n        };\n        ReactMount._updateRootComponent(prevComponent, nextWrappedElement, nextContext, container, updatedCallback);\n        return publicInst;\n      } else {\n        ReactMount.unmountComponentAtNode(container);\n      }\n    }\n\n    var reactRootElement = getReactRootElementInContainer(container);\n    var containerHasReactMarkup = reactRootElement && !!internalGetID(reactRootElement);\n    var containerHasNonRootReactChild = hasNonRootReactChild(container);\n\n    if (process.env.NODE_ENV !== 'production') {\n      process.env.NODE_ENV !== 'production' ? warning(!containerHasNonRootReactChild, 'render(...): Replacing React-rendered children with a new root ' + 'component. If you intended to update the children of this node, ' + 'you should instead have the existing children update their state ' + 'and render the new components instead of calling ReactDOM.render.') : void 0;\n\n      if (!containerHasReactMarkup || reactRootElement.nextSibling) {\n        var rootElementSibling = reactRootElement;\n        while (rootElementSibling) {\n          if (internalGetID(rootElementSibling)) {\n            process.env.NODE_ENV !== 'production' ? warning(false, 'render(): Target node has markup rendered by React, but there ' + 'are unrelated nodes as well. This is most commonly caused by ' + 'white-space inserted around server-rendered markup.') : void 0;\n            break;\n          }\n          rootElementSibling = rootElementSibling.nextSibling;\n        }\n      }\n    }\n\n    var shouldReuseMarkup = containerHasReactMarkup && !prevComponent && !containerHasNonRootReactChild;\n    var component = ReactMount._renderNewRootComponent(nextWrappedElement, container, shouldReuseMarkup, nextContext)._renderedComponent.getPublicInstance();\n    if (callback) {\n      callback.call(component);\n    }\n    return component;\n  },\n\n  /**\n   * Renders a React component into the DOM in the supplied `container`.\n   * See https://facebook.github.io/react/docs/top-level-api.html#reactdom.render\n   *\n   * If the React component was previously rendered into `container`, this will\n   * perform an update on it and only mutate the DOM as necessary to reflect the\n   * latest React component.\n   *\n   * @param {ReactElement} nextElement Component element to render.\n   * @param {DOMElement} container DOM element to render into.\n   * @param {?function} callback function triggered on completion\n   * @return {ReactComponent} Component instance rendered in `container`.\n   */\n  render: function (nextElement, container, callback) {\n    return ReactMount._renderSubtreeIntoContainer(null, nextElement, container, callback);\n  },\n\n  /**\n   * Unmounts and destroys the React component rendered in the `container`.\n   * See https://facebook.github.io/react/docs/top-level-api.html#reactdom.unmountcomponentatnode\n   *\n   * @param {DOMElement} container DOM element containing a React component.\n   * @return {boolean} True if a component was found in and unmounted from\n   *                   `container`\n   */\n  unmountComponentAtNode: function (container) {\n    // Various parts of our code (such as ReactCompositeComponent's\n    // _renderValidatedComponent) assume that calls to render aren't nested;\n    // verify that that's the case. (Strictly speaking, unmounting won't cause a\n    // render but we still don't expect to be in a render call here.)\n    process.env.NODE_ENV !== 'production' ? warning(ReactCurrentOwner.current == null, 'unmountComponentAtNode(): Render methods should be a pure function ' + 'of props and state; triggering nested component updates from render ' + 'is not allowed. If necessary, trigger nested updates in ' + 'componentDidUpdate. Check the render method of %s.', ReactCurrentOwner.current && ReactCurrentOwner.current.getName() || 'ReactCompositeComponent') : void 0;\n\n    !isValidContainer(container) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'unmountComponentAtNode(...): Target container is not a DOM element.') : _prodInvariant('40') : void 0;\n\n    if (process.env.NODE_ENV !== 'production') {\n      process.env.NODE_ENV !== 'production' ? warning(!nodeIsRenderedByOtherInstance(container), \"unmountComponentAtNode(): The node you're attempting to unmount \" + 'was rendered by another copy of React.') : void 0;\n    }\n\n    var prevComponent = getTopLevelWrapperInContainer(container);\n    if (!prevComponent) {\n      // Check if the node being unmounted was rendered by React, but isn't a\n      // root node.\n      var containerHasNonRootReactChild = hasNonRootReactChild(container);\n\n      // Check if the container itself is a React root node.\n      var isContainerReactRoot = container.nodeType === 1 && container.hasAttribute(ROOT_ATTR_NAME);\n\n      if (process.env.NODE_ENV !== 'production') {\n        process.env.NODE_ENV !== 'production' ? warning(!containerHasNonRootReactChild, \"unmountComponentAtNode(): The node you're attempting to unmount \" + 'was rendered by React and is not a top-level container. %s', isContainerReactRoot ? 'You may have accidentally passed in a React root node instead ' + 'of its container.' : 'Instead, have the parent component update its state and ' + 'rerender in order to remove this component.') : void 0;\n      }\n\n      return false;\n    }\n    delete instancesByReactRootID[prevComponent._instance.rootID];\n    ReactUpdates.batchedUpdates(unmountComponentFromNode, prevComponent, container, false);\n    return true;\n  },\n\n  _mountImageIntoNode: function (markup, container, instance, shouldReuseMarkup, transaction) {\n    !isValidContainer(container) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'mountComponentIntoNode(...): Target container is not valid.') : _prodInvariant('41') : void 0;\n\n    if (shouldReuseMarkup) {\n      var rootElement = getReactRootElementInContainer(container);\n      if (ReactMarkupChecksum.canReuseMarkup(markup, rootElement)) {\n        ReactDOMComponentTree.precacheNode(instance, rootElement);\n        return;\n      } else {\n        var checksum = rootElement.getAttribute(ReactMarkupChecksum.CHECKSUM_ATTR_NAME);\n        rootElement.removeAttribute(ReactMarkupChecksum.CHECKSUM_ATTR_NAME);\n\n        var rootMarkup = rootElement.outerHTML;\n        rootElement.setAttribute(ReactMarkupChecksum.CHECKSUM_ATTR_NAME, checksum);\n\n        var normalizedMarkup = markup;\n        if (process.env.NODE_ENV !== 'production') {\n          // because rootMarkup is retrieved from the DOM, various normalizations\n          // will have occurred which will not be present in `markup`. Here,\n          // insert markup into a <div> or <iframe> depending on the container\n          // type to perform the same normalizations before comparing.\n          var normalizer;\n          if (container.nodeType === ELEMENT_NODE_TYPE) {\n            normalizer = document.createElement('div');\n            normalizer.innerHTML = markup;\n            normalizedMarkup = normalizer.innerHTML;\n          } else {\n            normalizer = document.createElement('iframe');\n            document.body.appendChild(normalizer);\n            normalizer.contentDocument.write(markup);\n            normalizedMarkup = normalizer.contentDocument.documentElement.outerHTML;\n            document.body.removeChild(normalizer);\n          }\n        }\n\n        var diffIndex = firstDifferenceIndex(normalizedMarkup, rootMarkup);\n        var difference = ' (client) ' + normalizedMarkup.substring(diffIndex - 20, diffIndex + 20) + '\\n (server) ' + rootMarkup.substring(diffIndex - 20, diffIndex + 20);\n\n        !(container.nodeType !== DOC_NODE_TYPE) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'You\\'re trying to render a component to the document using server rendering but the checksum was invalid. This usually means you rendered a different component type or props on the client from the one on the server, or your render() methods are impure. React cannot handle this case due to cross-browser quirks by rendering at the document root. You should look for environment dependent code in your components and ensure the props are the same client and server side:\\n%s', difference) : _prodInvariant('42', difference) : void 0;\n\n        if (process.env.NODE_ENV !== 'production') {\n          process.env.NODE_ENV !== 'production' ? warning(false, 'React attempted to reuse markup in a container but the ' + 'checksum was invalid. This generally means that you are ' + 'using server rendering and the markup generated on the ' + 'server was not what the client was expecting. React injected ' + 'new markup to compensate which works but you have lost many ' + 'of the benefits of server rendering. Instead, figure out ' + 'why the markup being generated is different on the client ' + 'or server:\\n%s', difference) : void 0;\n        }\n      }\n    }\n\n    !(container.nodeType !== DOC_NODE_TYPE) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'You\\'re trying to render a component to the document but you didn\\'t use server rendering. We can\\'t do this without using server rendering due to cross-browser quirks. See ReactDOMServer.renderToString() for server rendering.') : _prodInvariant('43') : void 0;\n\n    if (transaction.useCreateElement) {\n      while (container.lastChild) {\n        container.removeChild(container.lastChild);\n      }\n      DOMLazyTree.insertTreeBefore(container, markup, null);\n    } else {\n      setInnerHTML(container, markup);\n      ReactDOMComponentTree.precacheNode(instance, container.firstChild);\n    }\n\n    if (process.env.NODE_ENV !== 'production') {\n      var hostNode = ReactDOMComponentTree.getInstanceFromNode(container.firstChild);\n      if (hostNode._debugID !== 0) {\n        ReactInstrumentation.debugTool.onHostOperation({\n          instanceID: hostNode._debugID,\n          type: 'mount',\n          payload: markup.toString()\n        });\n      }\n    }\n  }\n};\n\nmodule.exports = ReactMount;"]}