react-simple-form-inline-styles
Version:
Simple inline styles for React forms
595 lines (560 loc) • 1.57 MB
JavaScript
/******/ (function(modules) { // webpackBootstrap
/******/ var parentHotUpdateCallback = this["webpackHotUpdate"];
/******/ this["webpackHotUpdate"] =
/******/ function webpackHotUpdateCallback(chunkId, moreModules) {
/******/ hotAddUpdateChunk(chunkId, moreModules);
/******/ if(parentHotUpdateCallback) parentHotUpdateCallback(chunkId, moreModules);
/******/ }
/******/
/******/ function hotDownloadUpdateChunk(chunkId) {
/******/ var head = document.getElementsByTagName('head')[0];
/******/ var script = document.createElement('script');
/******/ script.type = 'text/javascript';
/******/ script.charset = 'utf-8';
/******/ script.src = __webpack_require__.p + "" + chunkId + "." + hotCurrentHash + ".hot-update.js";
/******/ head.appendChild(script);
/******/ }
/******/
/******/ function hotDownloadManifest(callback) {
/******/ if(typeof XMLHttpRequest === "undefined")
/******/ return callback(new Error("No browser support"));
/******/ try {
/******/ var request = new XMLHttpRequest();
/******/ var requestPath = __webpack_require__.p + "" + hotCurrentHash + ".hot-update.json";
/******/ request.open("GET", requestPath, true);
/******/ request.timeout = 10000;
/******/ request.send(null);
/******/ } catch(err) {
/******/ return callback(err);
/******/ }
/******/ request.onreadystatechange = function() {
/******/ if(request.readyState !== 4) return;
/******/ if(request.status === 0) {
/******/ // timeout
/******/ callback(new Error("Manifest request to " + requestPath + " timed out."));
/******/ } else if(request.status === 404) {
/******/ // no update available
/******/ callback();
/******/ } else if(request.status !== 200 && request.status !== 304) {
/******/ // other failure
/******/ callback(new Error("Manifest request to " + requestPath + " failed."));
/******/ } else {
/******/ // success
/******/ try {
/******/ var update = JSON.parse(request.responseText);
/******/ } catch(e) {
/******/ callback(e);
/******/ return;
/******/ }
/******/ callback(null, update);
/******/ }
/******/ };
/******/ }
/******/
/******/
/******/
/******/ var hotApplyOnUpdate = true;
/******/ var hotCurrentHash = "548d81978406e06a7aff";
/******/ var hotCurrentModuleData = {};
/******/ var hotCurrentParents = [];
/******/
/******/ function hotCreateRequire(moduleId) {
/******/ var me = installedModules[moduleId];
/******/ if(!me) return __webpack_require__;
/******/ var fn = function(request) {
/******/ if(me.hot.active) {
/******/ if(installedModules[request]) {
/******/ if(installedModules[request].parents.indexOf(moduleId) < 0)
/******/ installedModules[request].parents.push(moduleId);
/******/ if(me.children.indexOf(request) < 0)
/******/ me.children.push(request);
/******/ } else hotCurrentParents = [moduleId];
/******/ } else {
/******/ console.warn("[HMR] unexpected require(" + request + ") from disposed module " + moduleId);
/******/ hotCurrentParents = [];
/******/ }
/******/ return __webpack_require__(request);
/******/ };
/******/ for(var name in __webpack_require__) {
/******/ if(Object.prototype.hasOwnProperty.call(__webpack_require__, name)) {
/******/ fn[name] = __webpack_require__[name];
/******/ }
/******/ }
/******/ fn.e = function(chunkId, callback) {
/******/ if(hotStatus === "ready")
/******/ hotSetStatus("prepare");
/******/ hotChunksLoading++;
/******/ __webpack_require__.e(chunkId, function() {
/******/ try {
/******/ callback.call(null, fn);
/******/ } finally {
/******/ finishChunkLoading();
/******/ }
/******/ function finishChunkLoading() {
/******/ hotChunksLoading--;
/******/ if(hotStatus === "prepare") {
/******/ if(!hotWaitingFilesMap[chunkId]) {
/******/ hotEnsureUpdateChunk(chunkId);
/******/ }
/******/ if(hotChunksLoading === 0 && hotWaitingFiles === 0) {
/******/ hotUpdateDownloaded();
/******/ }
/******/ }
/******/ }
/******/ });
/******/ }
/******/ return fn;
/******/ }
/******/
/******/ function hotCreateModule(moduleId) {
/******/ var hot = {
/******/ // private stuff
/******/ _acceptedDependencies: {},
/******/ _declinedDependencies: {},
/******/ _selfAccepted: false,
/******/ _selfDeclined: false,
/******/ _disposeHandlers: [],
/******/
/******/ // Module API
/******/ active: true,
/******/ accept: function(dep, callback) {
/******/ if(typeof dep === "undefined")
/******/ hot._selfAccepted = true;
/******/ else if(typeof dep === "function")
/******/ hot._selfAccepted = dep;
/******/ else if(typeof dep === "number")
/******/ hot._acceptedDependencies[dep] = callback;
/******/ else for(var i = 0; i < dep.length; i++)
/******/ hot._acceptedDependencies[dep[i]] = callback;
/******/ },
/******/ decline: function(dep) {
/******/ if(typeof dep === "undefined")
/******/ hot._selfDeclined = true;
/******/ else if(typeof dep === "number")
/******/ hot._declinedDependencies[dep] = true;
/******/ else for(var i = 0; i < dep.length; i++)
/******/ hot._declinedDependencies[dep[i]] = true;
/******/ },
/******/ dispose: function(callback) {
/******/ hot._disposeHandlers.push(callback);
/******/ },
/******/ addDisposeHandler: function(callback) {
/******/ hot._disposeHandlers.push(callback);
/******/ },
/******/ removeDisposeHandler: function(callback) {
/******/ var idx = hot._disposeHandlers.indexOf(callback);
/******/ if(idx >= 0) hot._disposeHandlers.splice(idx, 1);
/******/ },
/******/
/******/ // Management API
/******/ check: hotCheck,
/******/ apply: hotApply,
/******/ status: function(l) {
/******/ if(!l) return hotStatus;
/******/ hotStatusHandlers.push(l);
/******/ },
/******/ addStatusHandler: function(l) {
/******/ hotStatusHandlers.push(l);
/******/ },
/******/ removeStatusHandler: function(l) {
/******/ var idx = hotStatusHandlers.indexOf(l);
/******/ if(idx >= 0) hotStatusHandlers.splice(idx, 1);
/******/ },
/******/
/******/ //inherit from previous dispose call
/******/ data: hotCurrentModuleData[moduleId]
/******/ };
/******/ return hot;
/******/ }
/******/
/******/ var hotStatusHandlers = [];
/******/ var hotStatus = "idle";
/******/
/******/ function hotSetStatus(newStatus) {
/******/ hotStatus = newStatus;
/******/ for(var i = 0; i < hotStatusHandlers.length; i++)
/******/ hotStatusHandlers[i].call(null, newStatus);
/******/ }
/******/
/******/ // while downloading
/******/ var hotWaitingFiles = 0;
/******/ var hotChunksLoading = 0;
/******/ var hotWaitingFilesMap = {};
/******/ var hotRequestedFilesMap = {};
/******/ var hotAvailibleFilesMap = {};
/******/ var hotCallback;
/******/
/******/ // The update info
/******/ var hotUpdate, hotUpdateNewHash;
/******/
/******/ function hotCheck(apply, callback) {
/******/ if(hotStatus !== "idle") throw new Error("check() is only allowed in idle status");
/******/ if(typeof apply === "function") {
/******/ hotApplyOnUpdate = false;
/******/ callback = apply;
/******/ } else {
/******/ hotApplyOnUpdate = apply;
/******/ callback = callback || function(err) { if(err) throw err };
/******/ }
/******/ hotSetStatus("check");
/******/ hotDownloadManifest(function(err, update) {
/******/ if(err) return callback(err);
/******/ if(!update) {
/******/ hotSetStatus("idle");
/******/ callback(null, null);
/******/ return;
/******/ }
/******/
/******/ hotRequestedFilesMap = {};
/******/ hotAvailibleFilesMap = {};
/******/ hotWaitingFilesMap = {};
/******/ for(var i = 0; i < update.c.length; i++)
/******/ hotAvailibleFilesMap[update.c[i]] = true;
/******/ hotUpdateNewHash = update.h;
/******/
/******/ hotSetStatus("prepare");
/******/ hotCallback = callback;
/******/ hotUpdate = {};
/******/ var chunkId = 0; {
/******/ hotEnsureUpdateChunk(chunkId);
/******/ }
/******/ if(hotStatus === "prepare" && hotChunksLoading === 0 && hotWaitingFiles === 0) {
/******/ hotUpdateDownloaded();
/******/ }
/******/ });
/******/ }
/******/
/******/ function hotAddUpdateChunk(chunkId, moreModules) {
/******/ if(!hotAvailibleFilesMap[chunkId] || !hotRequestedFilesMap[chunkId])
/******/ return;
/******/ hotRequestedFilesMap[chunkId] = false;
/******/ for(var moduleId in moreModules) {
/******/ if(Object.prototype.hasOwnProperty.call(moreModules, moduleId)) {
/******/ hotUpdate[moduleId] = moreModules[moduleId];
/******/ }
/******/ }
/******/ if(--hotWaitingFiles === 0 && hotChunksLoading === 0) {
/******/ hotUpdateDownloaded();
/******/ }
/******/ }
/******/
/******/ function hotEnsureUpdateChunk(chunkId) {
/******/ if(!hotAvailibleFilesMap[chunkId]) {
/******/ hotWaitingFilesMap[chunkId] = true;
/******/ } else {
/******/ hotRequestedFilesMap[chunkId] = true;
/******/ hotWaitingFiles++;
/******/ hotDownloadUpdateChunk(chunkId);
/******/ }
/******/ }
/******/
/******/ function hotUpdateDownloaded() {
/******/ hotSetStatus("ready");
/******/ var callback = hotCallback;
/******/ hotCallback = null;
/******/ if(!callback) return;
/******/ if(hotApplyOnUpdate) {
/******/ hotApply(hotApplyOnUpdate, callback);
/******/ } else {
/******/ var outdatedModules = [];
/******/ for(var id in hotUpdate) {
/******/ if(Object.prototype.hasOwnProperty.call(hotUpdate, id)) {
/******/ outdatedModules.push(+id);
/******/ }
/******/ }
/******/ callback(null, outdatedModules);
/******/ }
/******/ }
/******/
/******/ function hotApply(options, callback) {
/******/ if(hotStatus !== "ready") throw new Error("apply() is only allowed in ready status");
/******/ if(typeof options === "function") {
/******/ callback = options;
/******/ options = {};
/******/ } else if(options && typeof options === "object") {
/******/ callback = callback || function(err) { if(err) throw err };
/******/ } else {
/******/ options = {};
/******/ callback = callback || function(err) { if(err) throw err };
/******/ }
/******/
/******/ function getAffectedStuff(module) {
/******/ var outdatedModules = [module];
/******/ var outdatedDependencies = {};
/******/
/******/ var queue = outdatedModules.slice();
/******/ while(queue.length > 0) {
/******/ var moduleId = queue.pop();
/******/ var module = installedModules[moduleId];
/******/ if(!module || module.hot._selfAccepted)
/******/ continue;
/******/ if(module.hot._selfDeclined) {
/******/ return new Error("Aborted because of self decline: " + moduleId);
/******/ }
/******/ if(moduleId === 0) {
/******/ return;
/******/ }
/******/ for(var i = 0; i < module.parents.length; i++) {
/******/ var parentId = module.parents[i];
/******/ var parent = installedModules[parentId];
/******/ if(parent.hot._declinedDependencies[moduleId]) {
/******/ return new Error("Aborted because of declined dependency: " + moduleId + " in " + parentId);
/******/ }
/******/ if(outdatedModules.indexOf(parentId) >= 0) continue;
/******/ if(parent.hot._acceptedDependencies[moduleId]) {
/******/ if(!outdatedDependencies[parentId])
/******/ outdatedDependencies[parentId] = [];
/******/ addAllToSet(outdatedDependencies[parentId], [moduleId]);
/******/ continue;
/******/ }
/******/ delete outdatedDependencies[parentId];
/******/ outdatedModules.push(parentId);
/******/ queue.push(parentId);
/******/ }
/******/ }
/******/
/******/ return [outdatedModules, outdatedDependencies];
/******/ }
/******/ function addAllToSet(a, b) {
/******/ for(var i = 0; i < b.length; i++) {
/******/ var item = b[i];
/******/ if(a.indexOf(item) < 0)
/******/ a.push(item);
/******/ }
/******/ }
/******/
/******/ // at begin all updates modules are outdated
/******/ // the "outdated" status can propagate to parents if they don't accept the children
/******/ var outdatedDependencies = {};
/******/ var outdatedModules = [];
/******/ var appliedUpdate = {};
/******/ for(var id in hotUpdate) {
/******/ if(Object.prototype.hasOwnProperty.call(hotUpdate, id)) {
/******/ var moduleId = +id;
/******/ var result = getAffectedStuff(moduleId);
/******/ if(!result) {
/******/ if(options.ignoreUnaccepted)
/******/ continue;
/******/ hotSetStatus("abort");
/******/ return callback(new Error("Aborted because " + moduleId + " is not accepted"));
/******/ }
/******/ if(result instanceof Error) {
/******/ hotSetStatus("abort");
/******/ return callback(result);
/******/ }
/******/ appliedUpdate[moduleId] = hotUpdate[moduleId];
/******/ addAllToSet(outdatedModules, result[0]);
/******/ for(var moduleId in result[1]) {
/******/ if(Object.prototype.hasOwnProperty.call(result[1], moduleId)) {
/******/ if(!outdatedDependencies[moduleId])
/******/ outdatedDependencies[moduleId] = [];
/******/ addAllToSet(outdatedDependencies[moduleId], result[1][moduleId]);
/******/ }
/******/ }
/******/ }
/******/ }
/******/
/******/ // Store self accepted outdated modules to require them later by the module system
/******/ var outdatedSelfAcceptedModules = [];
/******/ for(var i = 0; i < outdatedModules.length; i++) {
/******/ var moduleId = outdatedModules[i];
/******/ if(installedModules[moduleId] && installedModules[moduleId].hot._selfAccepted)
/******/ outdatedSelfAcceptedModules.push({
/******/ module: moduleId,
/******/ errorHandler: installedModules[moduleId].hot._selfAccepted
/******/ });
/******/ }
/******/
/******/ // Now in "dispose" phase
/******/ hotSetStatus("dispose");
/******/ var queue = outdatedModules.slice();
/******/ while(queue.length > 0) {
/******/ var moduleId = queue.pop();
/******/ var module = installedModules[moduleId];
/******/ if(!module) continue;
/******/
/******/ var data = {};
/******/
/******/ // Call dispose handlers
/******/ var disposeHandlers = module.hot._disposeHandlers;
/******/ for(var j = 0; j < disposeHandlers.length; j++) {
/******/ var cb = disposeHandlers[j]
/******/ cb(data);
/******/ }
/******/ hotCurrentModuleData[moduleId] = data;
/******/
/******/ // disable module (this disables requires from this module)
/******/ module.hot.active = false;
/******/
/******/ // remove module from cache
/******/ delete installedModules[moduleId];
/******/
/******/ // remove "parents" references from all children
/******/ for(var j = 0; j < module.children.length; j++) {
/******/ var child = installedModules[module.children[j]];
/******/ if(!child) continue;
/******/ var idx = child.parents.indexOf(moduleId);
/******/ if(idx >= 0) {
/******/ child.parents.splice(idx, 1);
/******/ }
/******/ }
/******/ }
/******/
/******/ // remove outdated dependency from module children
/******/ for(var moduleId in outdatedDependencies) {
/******/ if(Object.prototype.hasOwnProperty.call(outdatedDependencies, moduleId)) {
/******/ var module = installedModules[moduleId];
/******/ var moduleOutdatedDependencies = outdatedDependencies[moduleId];
/******/ for(var j = 0; j < moduleOutdatedDependencies.length; j++) {
/******/ var dependency = moduleOutdatedDependencies[j];
/******/ var idx = module.children.indexOf(dependency);
/******/ if(idx >= 0) module.children.splice(idx, 1);
/******/ }
/******/ }
/******/ }
/******/
/******/ // Not in "apply" phase
/******/ hotSetStatus("apply");
/******/
/******/ hotCurrentHash = hotUpdateNewHash;
/******/
/******/ // insert new code
/******/ for(var moduleId in appliedUpdate) {
/******/ if(Object.prototype.hasOwnProperty.call(appliedUpdate, moduleId)) {
/******/ modules[moduleId] = appliedUpdate[moduleId];
/******/ }
/******/ }
/******/
/******/ // call accept handlers
/******/ var error = null;
/******/ for(var moduleId in outdatedDependencies) {
/******/ if(Object.prototype.hasOwnProperty.call(outdatedDependencies, moduleId)) {
/******/ var module = installedModules[moduleId];
/******/ var moduleOutdatedDependencies = outdatedDependencies[moduleId];
/******/ var callbacks = [];
/******/ for(var i = 0; i < moduleOutdatedDependencies.length; i++) {
/******/ var dependency = moduleOutdatedDependencies[i];
/******/ var cb = module.hot._acceptedDependencies[dependency];
/******/ if(callbacks.indexOf(cb) >= 0) continue;
/******/ callbacks.push(cb);
/******/ }
/******/ for(var i = 0; i < callbacks.length; i++) {
/******/ var cb = callbacks[i];
/******/ try {
/******/ cb(outdatedDependencies);
/******/ } catch(err) {
/******/ if(!error)
/******/ error = err;
/******/ }
/******/ }
/******/ }
/******/ }
/******/
/******/ // Load self accepted modules
/******/ for(var i = 0; i < outdatedSelfAcceptedModules.length; i++) {
/******/ var item = outdatedSelfAcceptedModules[i];
/******/ var moduleId = item.module;
/******/ hotCurrentParents = [moduleId];
/******/ try {
/******/ __webpack_require__(moduleId);
/******/ } catch(err) {
/******/ if(typeof item.errorHandler === "function") {
/******/ try {
/******/ item.errorHandler(err);
/******/ } catch(err) {
/******/ if(!error)
/******/ error = err;
/******/ }
/******/ } else if(!error)
/******/ error = err;
/******/ }
/******/ }
/******/
/******/ // handle errors in accept handlers and self accepted module load
/******/ if(error) {
/******/ hotSetStatus("fail");
/******/ return callback(error);
/******/ }
/******/
/******/ hotSetStatus("idle");
/******/ callback(null, outdatedModules);
/******/ }
/******/ // The module cache
/******/ var installedModules = {};
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/ // Check if module is in cache
/******/ if(installedModules[moduleId])
/******/ return installedModules[moduleId].exports;
/******/ // Create a new module (and put it into the cache)
/******/ var module = installedModules[moduleId] = {
/******/ exports: {},
/******/ id: moduleId,
/******/ loaded: false,
/******/ hot: hotCreateModule(moduleId),
/******/ parents: hotCurrentParents,
/******/ children: []
/******/ };
/******/ // Execute the module function
/******/ modules[moduleId].call(module.exports, module, module.exports, hotCreateRequire(moduleId));
/******/ // Flag the module as loaded
/******/ module.loaded = true;
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/ // expose the modules object (__webpack_modules__)
/******/ __webpack_require__.m = modules;
/******/ // expose the module cache
/******/ __webpack_require__.c = installedModules;
/******/ // __webpack_public_path__
/******/ __webpack_require__.p = "";
/******/ // __webpack_hash__
/******/ __webpack_require__.h = function() { return hotCurrentHash; };
/******/ // Load entry module and return exports
/******/ return hotCreateRequire(0)(0);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ function(module, exports, __webpack_require__) {
eval("__webpack_require__(1);\n__webpack_require__(2);\nmodule.exports = __webpack_require__(3);\n\n\n/*****************\n ** WEBPACK FOOTER\n ** multi main\n ** module id = 0\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///multi_main?");
/***/ },
/* 1 */
/***/ function(module, exports, __webpack_require__) {
eval("/* WEBPACK VAR INJECTION */(function(__resourceQuery) {var io = __webpack_require__(9);\r\nvar scriptElements = document.getElementsByTagName(\"script\");\r\nio = io.connect(true ?\r\n\t__resourceQuery.substr(1) :\r\n\tscriptElements[scriptElements.length-1].getAttribute(\"src\").replace(/\\/[^\\/]+$/, \"\")\r\n);\r\n\r\nvar hot = false;\r\nvar initial = true;\r\nvar currentHash = \"\";\r\n\r\nio.on(\"hot\", function() {\r\n\thot = true;\r\n\tconsole.log(\"[WDS] Hot Module Replacement enabled.\");\r\n});\r\n\r\nio.on(\"invalid\", function() {\r\n\tconsole.log(\"[WDS] App updated. Recompiling...\");\r\n});\r\n\r\nio.on(\"hash\", function(hash) {\r\n\tcurrentHash = hash;\r\n});\r\n\r\nio.on(\"ok\", function() {\r\n\tif(initial) return initial = false;\r\n\treloadApp();\r\n});\r\n\r\nio.on(\"warnings\", function(warnings) {\r\n\tconsole.log(\"[WDS] Warnings while compiling.\");\r\n\tfor(var i = 0; i < warnings.length; i++)\r\n\t\tconsole.warn(warnings[i]);\r\n\tif(initial) return initial = false;\r\n\treloadApp();\r\n});\r\n\r\nio.on(\"errors\", function(errors) {\r\n\tconsole.log(\"[WDS] Errors while compiling.\");\r\n\tfor(var i = 0; i < errors.length; i++)\r\n\t\tconsole.error(errors[i]);\r\n\tif(initial) return initial = false;\r\n\treloadApp();\r\n});\r\n\r\nio.on(\"proxy-error\", function(errors) {\r\n\tconsole.log(\"[WDS] Proxy error.\");\r\n\tfor(var i = 0; i < errors.length; i++)\r\n\t\tconsole.error(errors[i]);\r\n\tif(initial) return initial = false;\r\n\treloadApp();\r\n});\r\n\r\nio.on(\"disconnect\", function() {\r\n\tconsole.error(\"[WDS] Disconnected!\");\r\n});\r\n\r\nfunction reloadApp() {\r\n\tif(hot) {\r\n\t\tconsole.log(\"[WDS] App hot update...\");\r\n\t\twindow.postMessage(\"webpackHotUpdate\" + currentHash, \"*\");\r\n\t} else {\r\n\t\tconsole.log(\"[WDS] App updated. Reloading...\");\r\n\t\twindow.location.reload();\r\n\t}\r\n}\n/* WEBPACK VAR INJECTION */}.call(exports, \"?http://0.0.0.0:8080\"))\n\n/*****************\n ** WEBPACK FOOTER\n ** (webpack)-dev-server/client?http://0.0.0.0:8080\n ** module id = 1\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///(webpack)-dev-server/client?");
/***/ },
/* 2 */
/***/ function(module, exports, __webpack_require__) {
eval("/*\r\n\tMIT License http://www.opensource.org/licenses/mit-license.php\r\n\tAuthor Tobias Koppers @sokra\r\n*/\r\nif(true) {\r\n\tvar lastData;\r\n\tvar upToDate = function upToDate() {\r\n\t\treturn lastData.indexOf(__webpack_require__.h()) >= 0;\r\n\t};\r\n\tvar check = function check() {\r\n\t\tmodule.hot.check(function(err, updatedModules) {\r\n\t\t\tif(err) {\r\n\t\t\t\tif(module.hot.status() in {abort:1,fail:1}) {\r\n\t\t\t\t\tconsole.warn(\"[HMR] Cannot check for update. Need to do a full reload!\");\r\n\t\t\t\t\tconsole.warn(\"[HMR] \" + err.stack || err.message);\r\n\t\t\t\t} else {\r\n\t\t\t\t\tconsole.warn(\"[HMR] Update check failed: \" + err.stack || err.message);\r\n\t\t\t\t}\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\r\n\t\t\tif(!updatedModules) {\r\n\t\t\t\tconsole.warn(\"[HMR] Cannot find update. Need to do a full reload!\");\r\n\t\t\t\tconsole.warn(\"[HMR] (Probably because of restarting the webpack-dev-server)\")\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\r\n\t\t\tmodule.hot.apply({\r\n\t\t\t\tignoreUnaccepted: true\r\n\t\t\t}, function(err, renewedModules) {\r\n\t\t\t\tif(err) {\r\n\t\t\t\t\tif(module.hot.status() in {abort:1,fail:1}) {\r\n\t\t\t\t\t\tconsole.warn(\"[HMR] Cannot apply update. Need to do a full reload!\");\r\n\t\t\t\t\t\tconsole.warn(\"[HMR] \" + err.stack || err.message);\r\n\t\t\t\t\t} else {\r\n\t\t\t\t\t\tconsole.warn(\"[HMR] Update failed: \" + err.stack || err.message);\r\n\t\t\t\t\t}\r\n\t\t\t\t\treturn;\r\n\t\t\t\t}\r\n\r\n\t\t\t\tif(!upToDate()) {\r\n\t\t\t\t\tcheck();\r\n\t\t\t\t}\r\n\r\n\t\t\t\t__webpack_require__(4)(updatedModules, renewedModules);\r\n\r\n\t\t\t\tif(upToDate()) {\r\n\t\t\t\t\tconsole.log(\"[HMR] App is up to date.\");\r\n\t\t\t\t}\r\n\t\t\t});\r\n\t\t});\r\n\t};\r\n\tvar addEventListener = window.addEventListener ? function(eventName, listener) {\r\n\t\twindow.addEventListener(eventName, listener, false);\r\n\t} : function (eventName, listener) {\r\n\t\twindow.attachEvent('on' + eventName, listener);\r\n\t};\r\n\taddEventListener(\"message\", function(event) {\r\n\t\tif(typeof event.data === \"string\" && event.data.indexOf(\"webpackHotUpdate\") === 0) {\r\n\t\t\tlastData = event.data;\r\n\t\t\tif(!upToDate() && module.hot.status() === \"idle\") {\r\n\t\t\t\tconsole.log(\"[HMR] Checking for updates on the server...\");\r\n\t\t\t\tcheck();\r\n\t\t\t}\r\n\t\t}\r\n\t});\r\n\tconsole.log(\"[HMR] Waiting for update signal from WDS...\");\r\n} else {\r\n\tthrow new Error(\"[HMR] Hot Module Replacement is disabled.\");\r\n}\r\n\n\n/*****************\n ** WEBPACK FOOTER\n ** (webpack)/hot/only-dev-server.js\n ** module id = 2\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///(webpack)/hot/only-dev-server.js?");
/***/ },
/* 3 */
/***/ function(module, exports, __webpack_require__) {
eval("/* WEBPACK VAR INJECTION */(function(module) {/* REACT HOT LOADER */ if (true) { (function () { var ReactHotAPI = __webpack_require__(11), RootInstanceProvider = __webpack_require__(5), ReactMount = __webpack_require__(10), React = __webpack_require__(12); module.makeHot = module.hot.data ? module.hot.data.makeHot : ReactHotAPI(function () { return RootInstanceProvider.getRootInstances(ReactMount); }, React); })(); } (function () {\n\nvar Examples, React;\n\nReact = __webpack_require__(12);\n\nExamples = __webpack_require__(6);\n\nReact.renderComponent(React.createElement(Examples, null), document.body);\n\n\n/* REACT HOT LOADER */ })(); if (true) { (function () { module.hot.dispose(function (data) { data.makeHot = module.makeHot; }); if (module.exports && module.makeHot) { var makeExportsHot = __webpack_require__(7), foundReactClasses = false; if (makeExportsHot(module, __webpack_require__(12))) { foundReactClasses = true; } var shouldAcceptModule = true && foundReactClasses; if (shouldAcceptModule) { module.hot.accept(function (err) { if (err) { console.error(\"Cannot not apply hot update to \" + \"index.cjsx\" + \": \" + err.message); } }); } } })(); }\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(8)(module)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./examples/index.cjsx\n ** module id = 3\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./examples/index.cjsx?");
/***/ },
/* 4 */
/***/ function(module, exports, __webpack_require__) {
eval("/*\r\n\tMIT License http://www.opensource.org/licenses/mit-license.php\r\n\tAuthor Tobias Koppers @sokra\r\n*/\r\nmodule.exports = function(updatedModules, renewedModules) {\r\n\tvar unacceptedModules = updatedModules.filter(function(moduleId) {\r\n\t\treturn renewedModules && renewedModules.indexOf(moduleId) < 0;\r\n\t});\r\n\r\n\tif(unacceptedModules.length > 0) {\r\n\t\tconsole.warn(\"[HMR] The following modules couldn't be hot updated: (They would need a full reload!)\");\r\n\t\tunacceptedModules.forEach(function(moduleId) {\r\n\t\t\tconsole.warn(\"[HMR] - \" + moduleId);\r\n\t\t});\r\n\t}\r\n\r\n\tif(!renewedModules || renewedModules.length === 0) {\r\n\t\tconsole.log(\"[HMR] Nothing hot updated.\");\r\n\t} else {\r\n\t\tconsole.log(\"[HMR] Updated modules:\");\r\n\t\trenewedModules.forEach(function(moduleId) {\r\n\t\t\tconsole.log(\"[HMR] - \" + moduleId);\r\n\t\t});\r\n\t}\r\n};\r\n\n\n/*****************\n ** WEBPACK FOOTER\n ** (webpack)/hot/log-apply-result.js\n ** module id = 4\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///(webpack)/hot/log-apply-result.js?");
/***/ },
/* 5 */
/***/ function(module, exports, __webpack_require__) {
eval("'use strict';\n\nvar getRootInstancesFromReactMount = __webpack_require__(13);\n\nvar injectedProvider = null,\n didWarn = false;\n\nfunction warnOnce() {\n if (!didWarn) {\n console.warn(\n 'It appears that React Hot Loader isn\\'t configured correctly. ' +\n 'If you\\'re using NPM, make sure your dependencies don\\'t drag duplicate React distributions into their node_modules and that require(\"react\") corresponds to the React instance you render your app with.',\n 'If you\\'re using a precompiled version of React, see https://github.com/gaearon/react-hot-loader/tree/master/docs#usage-with-external-react for integration instructions.'\n );\n }\n\n didWarn = true;\n}\n\nvar RootInstanceProvider = {\n injection: {\n injectProvider: function (provider) {\n injectedProvider = provider;\n }\n },\n\n getRootInstances: function (ReactMount) {\n if (injectedProvider) {\n return injectedProvider.getRootInstances();\n }\n\n var instances = ReactMount && getRootInstancesFromReactMount(ReactMount) || [];\n if (!Object.keys(instances).length) {\n warnOnce();\n }\n\n return instances;\n }\n};\n\nmodule.exports = RootInstanceProvider;\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react-hot-loader/RootInstanceProvider.js\n ** module id = 5\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react-hot-loader/RootInstanceProvider.js?");
/***/ },
/* 6 */
/***/ function(module, exports, __webpack_require__) {
eval("/* WEBPACK VAR INJECTION */(function(module) {/* REACT HOT LOADER */ if (true) { (function () { var ReactHotAPI = __webpack_require__(11), RootInstanceProvider = __webpack_require__(5), ReactMount = __webpack_require__(10), React = __webpack_require__(12); module.makeHot = module.hot.data ? module.hot.data.makeHot : ReactHotAPI(function () { return RootInstanceProvider.getRootInstances(ReactMount); }, React); })(); } (function () {\n\nvar Container, FormStyles, Headroom, React, Typography, rhythm;\n\nReact = __webpack_require__(12);\n\nFormStyles = __webpack_require__(14);\n\nContainer = __webpack_require__(41).Container;\n\nHeadroom = __webpack_require__(42);\n\nTypography = __webpack_require__(43);\n\nrhythm = Typography().rhythm;\n\nmodule.exports = React.createClass({\n render: function() {\n var button, form, input, lable, ref;\n ref = FormStyles(rhythm), form = ref.form, lable = ref.lable, input = ref.input, button = ref.button;\n return React.createElement(\"div\", null, React.createElement(Headroom, {\n \"style\": {\n background: 'pink',\n padding: 8\n },\n \"wrapperStyle\": {\n marginBottom: 32\n }\n }, React.createElement(Container, {\n \"style\": {\n maxWidth: '1000px'\n }\n }, React.createElement(\"h1\", null, \"React Simple Inline Form Styles\"))), React.createElement(Container, {\n \"style\": {\n maxWidth: '1000px'\n }\n }, React.createElement(\"a\", {\n \"href\": \"https://github.com/KyleAMathews/react-simple-form-inline-styles\"\n }, \"Code on Github\"), React.createElement(\"br\", null), React.createElement(\"br\", null), React.createElement(\"form\", {\n \"style\": form\n }, React.createElement(\"label\", {\n \"style\": label\n }, \"Yo doggy\"), React.createElement(\"input\", {\n \"type\": \"text\"\n }))));\n }\n});\n\n\n/* REACT HOT LOADER */ })(); if (true) { (function () { module.hot.dispose(function (data) { data.makeHot = module.makeHot; }); if (module.exports && module.makeHot) { var makeExportsHot = __webpack_require__(7), foundReactClasses = false; if (makeExportsHot(module, __webpack_require__(12))) { foundReactClasses = true; } var shouldAcceptModule = true && foundReactClasses; if (shouldAcceptModule) { module.hot.accept(function (err) { if (err) { console.error(\"Cannot not apply hot update to \" + \"examples.cjsx\" + \": \" + err.message); } }); } } })(); }\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(8)(module)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./examples/examples.cjsx\n ** module id = 6\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./examples/examples.cjsx?");
/***/ },
/* 7 */
/***/ function(module, exports, __webpack_require__) {
eval("'use strict';\n\nvar isReactClassish = __webpack_require__(15),\n isReactElementish = __webpack_require__(16);\n\nfunction makeExportsHot(m, React) {\n if (isReactElementish(m.exports)) {\n return false;\n }\n\n var freshExports = m.exports,\n foundReactClasses = false;\n\n if (isReactClassish(m.exports, React)) {\n m.exports = m.makeHot(m.exports, '__MODULE_EXPORTS');\n foundReactClasses = true;\n }\n\n for (var key in m.exports) {\n if (Object.prototype.hasOwnProperty.call(freshExports, key) &&\n isReactClassish(freshExports[key], React)) {\n if (Object.getOwnPropertyDescriptor(m.exports, key).writable) {\n m.exports[key] = m.makeHot(freshExports[key], '__MODULE_EXPORTS_' + key);\n foundReactClasses = true;\n } else {\n console.warn(\"Can't make class \" + key + \" hot reloadable due to being read-only. You can exclude files or directories (for example, /node_modules/) using 'exclude' option in loader configuration.\");\n }\n }\n }\n\n return foundReactClasses;\n}\n\nmodule.exports = makeExportsHot;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react-hot-loader/makeExportsHot.js\n ** module id = 7\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react-hot-loader/makeExportsHot.js?");
/***/ },
/* 8 */
/***/ function(module, exports, __webpack_require__) {
eval("module.exports = function(module) {\r\n\tif(!module.webpackPolyfill) {\r\n\t\tmodule.deprecate = function() {};\r\n\t\tmodule.paths = [];\r\n\t\t// module.parent = undefined by default\r\n\t\tmodule.children = [];\r\n\t\tmodule.webpackPolyfill = 1;\r\n\t}\r\n\treturn module;\r\n}\r\n\n\n/*****************\n ** WEBPACK FOOTER\n ** (webpack)/buildin/module.js\n ** module id = 8\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///(webpack)/buildin/module.js?");
/***/ },
/* 9 */
/***/ function(module, exports, __webpack_require__) {
eval("module.exports = __webpack_require__(17);\r\n\n\n/*****************\n ** WEBPACK FOOTER\n ** (webpack)-dev-server/client/web_modules/socket.io/index.js\n ** module id = 9\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///(webpack)-dev-server/client/web_modules/socket.io/index.js?");
/***/ },
/* 10 */
/***/ function(module, exports, __webpack_require__) {
eval("/* WEBPACK VAR INJECTION */(function(process) {/**\n * Copyright 2013-2015, 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 * @providesModule ReactMount\n */\n\n'use strict';\n\nvar DOMProperty = __webpack_require__(18);\nvar ReactBrowserEventEmitter = __webpack_require__(19);\nvar ReactCurrentOwner = __webpack_require__(20);\nvar ReactElement = __webpack_require__(21);\nvar ReactElementValidator = __webpack_require__(22);\nvar ReactEmptyComponent = __webpack_require__(23);\nvar ReactInstanceHandles = __webpack_require__(24);\nvar ReactInstanceMap = __webpack_require__(25);\nvar ReactMarkupChecksum = __webpack_require__(26);\nvar ReactPerf = __webpack_require__(27);\nvar ReactReconciler = __webpack_require__(28);\nvar ReactUpdateQueue = __webpack_require__(29);\nvar ReactUpdates = __webpack_require__(30);\n\nvar emptyObject = __webpack_require__(31);\nvar containsNode = __webpack_require__(32);\nvar getReactRootElementInContainer = __webpack_require__(33);\nvar instantiateReactComponent = __webpack_require__(34);\nvar invariant = __webpack_require__(35);\nvar setInnerHTML = __webpack_require__(36);\nvar shouldUpdateReactComponent = __webpack_require__(37);\nvar warning = __webpack_require__(38);\n\nvar SEPARATOR = ReactInstanceHandles.SEPARATOR;\n\nvar ATTR_NAME = DOMProperty.ID_ATTRIBUTE_NAME;\nvar nodeCache = {};\n\nvar ELEMENT_NODE_TYPE = 1;\nvar DOC_NODE_TYPE = 9;\n\n/** Mapping from reactRootID to React component instance. */\nvar instancesByReactRootID = {};\n\n/** Mapping from reactRootID to `container` nodes. */\nvar containersByReactRootID = {};\n\nif (\"production\" !== process.env.NODE_ENV) {\n /** __DEV__-only mapping from reactRootID to root elements. */\n var rootElementsByReactRootID = {};\n}\n\n// Used to store breadth-first search state in findComponentRoot.\nvar findComponentRootReusableArray = [];\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} container DOM element that may contain a React component.\n * @return {?string} A \"reactRoot\" ID, if a React component is rendered.\n */\nfunction getReactRootID(container) {\n var rootElement = getReactRootElementInContainer(container);\n return rootElement && ReactMount.getID(rootElement);\n}\n\n/**\n * Accessing node[ATTR_NAME] or calling getAttribute(ATTR_NAME) on a form\n * element can return its control whose name or ID equals ATTR_NAME. All\n * DOM nodes support `getAttributeNode` but this can also get called on\n * other objects so just return '' if we're given something other than a\n * DOM node (such as window).\n *\n * @param {?DOMElement|DOMWindow|DOMDocument|DOMTextNode} node DOM node.\n * @return {string} ID of the supplied `domNode`.\n */\nfunction getID(node) {\n var id = internalGetID(node);\n if (id) {\n if (nodeCache.hasOwnProperty(id)) {\n var cached = nodeCache[id];\n if (cached !== node) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n !isValid(cached, id),\n 'ReactMount: Two valid but unequal nodes with the same `%s`: %s',\n ATTR_NAME, id\n ) : invariant(!isValid(cached, id)));\n\n nodeCache[id] = node;\n }\n } else {\n nodeCache[id] = node;\n }\n }\n\n return id;\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 && node.getAttribute && node.getAttribute(ATTR_NAME) || '';\n}\n\n/**\n * Sets the React-specific ID of the given node.\n *\n * @param {DOMElement} node The DOM node whose ID will be set.\n * @param {string} id The value of the ID attribute.\n */\nfunction setID(node, id) {\n var oldID = internalGetID(node);\n if (oldID !== id) {\n delete nodeCache[oldID];\n }\n node.setAttribute(ATTR_NAME, id);\n nodeCache[id] = node;\n}\n\n/**\n * Finds the node with the supplied React-generated DOM ID.\n *\n * @param {string} id A React-generated DOM ID.\n * @return {DOMElement} DOM node with the suppled `id`.\n * @internal\n */\nfunction getNode(id) {\n if (!nodeCache.hasOwnProperty(id) || !isValid(nodeCache[id], id)) {\n nodeCache[id] = ReactMount.findReactNodeByID(id);\n }\n return nodeCache[id];\n}\n\n/**\n * Finds the node with the supplied public React instance.\n *\n * @param {*} instance A public React instance.\n * @return {?DOMElement} DOM node with the suppled `id`.\n * @internal\n */\nfunction getNodeFromInstance(instance) {\n var id = ReactInstanceMap.get(instance)._rootNodeID;\n if (ReactEmptyComponent.isNullComponentID(id)) {\n return null;\n }\n if (!nodeCache.hasOwnProperty(id) || !isValid(nodeCache[id], id)) {\n nodeCache[id] = ReactMount.findReactNodeByID(id);\n }\n return nodeCache[id];\n}\n\n/**\n * A node is \"valid\" if it is contained by a currently mounted container.\n *\n * This means that the node does not have to be contained by a document in\n * order to be considered valid.\n *\n * @param {?DOMElement} node The candidate DOM node.\n * @param {string} id The expected ID of the node.\n * @return {boolean} Whether the node is contained by a mounted container.\n */\nfunction isValid(node, id) {\n if (node) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n internalGetID(node) === id,\n 'ReactMount: Unexpected modification of `%s`',\n ATTR_NAME\n ) : invariant(internalGetID(node) === id));\n\n var container = ReactMount.findReactContainerForID(id);\n if (container && containsNode(container, node)) {\n return true;\n }\n }\n\n return false;\n}\n\n/**\n * Causes the cache to forget about one React-specific ID.\n *\n * @param {string} id The ID to forget.\n */\nfunction purgeID(id) {\n delete nodeCache[id];\n}\n\nvar deepestNodeSoFar = null;\nfunction findDeepestCachedAncestorImpl(ancestorID) {\n var ancestor = nodeCache[ancestorID];\n if (ancestor && isValid(ancestor, ancestorID)) {\n deepestNodeSoFar = ancestor;\n } else {\n // This node isn't populated in the cache, so presumably none of its\n // descendants are. Break out of the loop.\n return false;\n }\n}\n\n/**\n * Return the deepest cached node whose ID is a prefix of `targetID`.\n */\nfunction findDeepestCachedAncestor(targetID) {\n deepestNodeSoFar = null;\n ReactInstanceHandles.traverseAncestors(\n targetID,\n findDeepestCachedAncestorImpl\n );\n\n var foundNode = deepestNodeSoFar;\n deepestNodeSoFar = null;\n return foundNode;\n}\n\n/**\n * Mounts this component and inserts it into the DOM.\n *\n * @param {ReactComponent} componentInstance The instance to mount.\n * @param {string} rootID DOM ID of the root node.\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(\n componentInstance,\n rootID,\n container,\n transaction,\n shouldReuseMarkup) {\n var markup = ReactReconciler.mountComponent(\n componentInstance, rootID, transaction, emptyObject\n );\n componentInstance._isTopLevel = true;\n ReactMount._mountImageIntoNode(markup, container, shouldReuseMarkup);\n}\n\n/**\n * Batched mount.\n *\n * @param {ReactComponent} componentInstance The instance to mount.\n * @param {string} rootID DOM ID of the root node.\n * @param {DOMElement} container DOM element to mount into.\n * @param {boolean} shouldReuseMarkup If true, do not insert markup\n */\nfunction batchedMountComponentIntoNode(\n componentInstance,\n rootID,\n container,\n shouldReuseMarkup) {\n var transaction = ReactUpdates.ReactReconcileTransaction.getPooled();\n transaction.perform(\n mountComponentIntoNode,\n null,\n componentInstance,\n rootID,\n container,\n transaction,\n shouldReuseMarkup\n );\n ReactUpdates.ReactReconcileTransaction.release(transaction);\n}\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 /** Exposed for debugging purposes **/\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(\n prevComponent,\n nextElement,\n container,\n callback) {\n if (\"production\" !== process.env.NODE_ENV) {\n ReactElementValidator.checkAndWarnForMutatedProps(nextElement);\n }\n\n ReactMount.scrollMonitor(container, function() {\n ReactUpdateQueue.enqueueElementInternal(prevComponent, nextElement);\n if (callback) {\n ReactUpdateQueue.enqueueCallbackInternal(prevComponent, callback);\n }\n });\n\n if (\"production\" !== process.env.NODE_ENV) {\n // Record the root element in case it later gets transplanted.\n rootElementsByReactRootID[getReactRootID(container)] =\n getReactRootElementInContainer(container);\n }\n\n return prevComponent;\n },\n\n /**\n * Register a component into the instance map and starts scroll value\n * monitoring\n * @param {ReactComponent} nextComponent component instance to render\n * @param {DOMElement} container container to render into\n * @return {string} reactRoot ID prefix\n */\n _registerComponent: function(nextComponent, container) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n container && (\n (container.nodeType === ELEMENT_NODE_TYPE || container.nodeType === DOC_NODE_TYPE)\n ),\n '_registerComponent(...): Target container is not a DOM element.'\n ) : invariant(container && (\n (container.nodeType === ELEMENT_NODE_TYPE || container.nodeType === DOC_NODE_TYPE)\n )));\n\n ReactBrowserEventEmitter.ensureScrollValueMonitoring();\n\n var reactRootID = ReactMount.registerContainer(container);\n instancesByReactRootID[reactRootID] = nextComponent;\n return reactRootID;\n },\n\n /**\n * Render a new component into the DOM.\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(\n nextElement,\n container,\n shouldReuseMarkup\n ) {\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 (\"production\" !== process.env.NODE_ENV ? warning(\n ReactCurrentOwner.current == null,\n '_renderNewRootComponent(): Render methods should be a pure function ' +\n 'of props and state; triggering nested component updates from ' +\n 'render is not allowed. If necessary, trigger nested updates in ' +\n 'componentDidUpdate.'\n ) : null);\n\n var componentInstance = instantiateReactComponent(nextElement, null);\n var reactRootID = ReactMount._registerComponent(\n componentInstance,\n container\n );\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(\n batchedMountComponentIntoNode,\n componentInstance,\n reactRootID,\n container,\n shouldReuseMarkup\n );\n\n if (\"production\" !== process.env.NODE_ENV) {\n // Record the root element in case it later gets transplanted.\n rootElementsByReactRootID[reactRootID] =\n getReactRootElementInContainer(container);\n }\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 {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 (\"production\" !== process.env.NODE_ENV ? invariant(\n ReactElement.isValidElement(nextElement),\n 'React.render(): Invalid component element.%s',\n (\n typeof nextElement === 'string' ?\n ' Instead of passing an element string, make sure to instantiate ' +\n 'it by passing it to React.createElement.' :\n typeof nextElement === 'function' ?\n ' Instead of passing a component class, make sure to instantiate ' +\n 'it by passing it to React.createElement.' :\n // Check if it quacks like an element\n nextElement != null && nextElement.props