mirror of
https://github.com/reduxjs/redux-devtools.git
synced 2025-10-24 12:41:01 +03:00
2331 lines
1.0 MiB
2331 lines
1.0 MiB
/******/ (function(modules) { // webpackBootstrap
|
||
/******/ var parentHotUpdateCallback = this["webpackHotUpdate"];
|
||
/******/ this["webpackHotUpdate"] =
|
||
/******/ function webpackHotUpdateCallback(chunkId, moreModules) { // eslint-disable-line no-unused-vars
|
||
/******/ hotAddUpdateChunk(chunkId, moreModules);
|
||
/******/ if(parentHotUpdateCallback) parentHotUpdateCallback(chunkId, moreModules);
|
||
/******/ }
|
||
/******/
|
||
/******/ function hotDownloadUpdateChunk(chunkId) { // eslint-disable-line no-unused-vars
|
||
/******/ 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) { // eslint-disable-line no-unused-vars
|
||
/******/ 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 = "98f66c879188c1260a0e"; // eslint-disable-line no-unused-vars
|
||
/******/ var hotCurrentModuleData = {};
|
||
/******/ var hotCurrentParents = []; // eslint-disable-line no-unused-vars
|
||
/******/
|
||
/******/ function hotCreateRequire(moduleId) { // eslint-disable-line no-unused-vars
|
||
/******/ 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) { // eslint-disable-line no-unused-vars
|
||
/******/ 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 === "object")
|
||
/******/ for(var i = 0; i < dep.length; i++)
|
||
/******/ hot._acceptedDependencies[dep[i]] = callback;
|
||
/******/ else
|
||
/******/ hot._acceptedDependencies[dep] = 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 toModuleId(id) {
|
||
/******/ return (+id) + "" === id ? +id : id;
|
||
/******/ }
|
||
/******/
|
||
/******/ 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; { // eslint-disable-line no-lone-blocks
|
||
/******/ /*globals chunkId */
|
||
/******/ hotEnsureUpdateChunk(chunkId);
|
||
/******/ }
|
||
/******/ if(hotStatus === "prepare" && hotChunksLoading === 0 && hotWaitingFiles === 0) {
|
||
/******/ hotUpdateDownloaded();
|
||
/******/ }
|
||
/******/ });
|
||
/******/ }
|
||
/******/
|
||
/******/ function hotAddUpdateChunk(chunkId, moreModules) { // eslint-disable-line no-unused-vars
|
||
/******/ 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(toModuleId(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 = toModuleId(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 = "/static/";
|
||
|
||
/******/ // __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__(56);\nmodule.exports = __webpack_require__(58);\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__(2);\r\nvar stripAnsi = __webpack_require__(54);\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(\"still-ok\", function() {\r\n\tconsole.log(\"[WDS] Nothing changed.\")\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(stripAnsi(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(stripAnsi(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(stripAnsi(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}\r\n\n/* WEBPACK VAR INJECTION */}.call(exports, \"?http://localhost:3000\"))\n\n/*****************\n ** WEBPACK FOOTER\n ** (webpack)-dev-server/client?http://localhost:3000\n ** module id = 1\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///(webpack)-dev-server/client?");
|
||
|
||
/***/ },
|
||
/* 2 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("\nmodule.exports = __webpack_require__(3);\n\n\n/*****************\n ** WEBPACK FOOTER\n ** (webpack)-dev-server/~/socket.io-client/index.js\n ** module id = 2\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///(webpack)-dev-server/~/socket.io-client/index.js?");
|
||
|
||
/***/ },
|
||
/* 3 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("\n/**\n * Module dependencies.\n */\n\nvar url = __webpack_require__(5);\nvar parser = __webpack_require__(7);\nvar Manager = __webpack_require__(14);\nvar debug = __webpack_require__(4)('socket.io-client');\n\n/**\n * Module exports.\n */\n\nmodule.exports = exports = lookup;\n\n/**\n * Managers cache.\n */\n\nvar cache = exports.managers = {};\n\n/**\n * Looks up an existing `Manager` for multiplexing.\n * If the user summons:\n *\n * `io('http://localhost/a');`\n * `io('http://localhost/b');`\n *\n * We reuse the existing instance based on same scheme/port/host,\n * and we initialize sockets for each namespace.\n *\n * @api public\n */\n\nfunction lookup(uri, opts) {\n if (typeof uri == 'object') {\n opts = uri;\n uri = undefined;\n }\n\n opts = opts || {};\n\n var parsed = url(uri);\n var source = parsed.source;\n var id = parsed.id;\n var io;\n\n if (opts.forceNew || opts['force new connection'] || false === opts.multiplex) {\n debug('ignoring socket cache for %s', source);\n io = Manager(source, opts);\n } else {\n if (!cache[id]) {\n debug('new io instance for %s', source);\n cache[id] = Manager(source, opts);\n }\n io = cache[id];\n }\n\n return io.socket(parsed.path);\n}\n\n/**\n * Protocol version.\n *\n * @api public\n */\n\nexports.protocol = parser.protocol;\n\n/**\n * `connect`.\n *\n * @param {String} uri\n * @api public\n */\n\nexports.connect = lookup;\n\n/**\n * Expose constructors for standalone build.\n *\n * @api public\n */\n\nexports.Manager = __webpack_require__(14);\nexports.Socket = __webpack_require__(46);\n\n\n/*****************\n ** WEBPACK FOOTER\n ** (webpack)-dev-server/~/socket.io-client/lib/index.js\n ** module id = 3\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///(webpack)-dev-server/~/socket.io-client/lib/index.js?");
|
||
|
||
/***/ },
|
||
/* 4 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("\n/**\n * Expose `debug()` as the module.\n */\n\nmodule.exports = debug;\n\n/**\n * Create a debugger with the given `name`.\n *\n * @param {String} name\n * @return {Type}\n * @api public\n */\n\nfunction debug(name) {\n if (!debug.enabled(name)) return function(){};\n\n return function(fmt){\n fmt = coerce(fmt);\n\n var curr = new Date;\n var ms = curr - (debug[name] || curr);\n debug[name] = curr;\n\n fmt = name\n + ' '\n + fmt\n + ' +' + debug.humanize(ms);\n\n // This hackery is required for IE8\n // where `console.log` doesn't have 'apply'\n window.console\n && console.log\n && Function.prototype.apply.call(console.log, console, arguments);\n }\n}\n\n/**\n * The currently active debug mode names.\n */\n\ndebug.names = [];\ndebug.skips = [];\n\n/**\n * Enables a debug mode by name. This can include modes\n * separated by a colon and wildcards.\n *\n * @param {String} name\n * @api public\n */\n\ndebug.enable = function(name) {\n try {\n localStorage.debug = name;\n } catch(e){}\n\n var split = (name || '').split(/[\\s,]+/)\n , len = split.length;\n\n for (var i = 0; i < len; i++) {\n name = split[i].replace('*', '.*?');\n if (name[0] === '-') {\n debug.skips.push(new RegExp('^' + name.substr(1) + '$'));\n }\n else {\n debug.names.push(new RegExp('^' + name + '$'));\n }\n }\n};\n\n/**\n * Disable debug output.\n *\n * @api public\n */\n\ndebug.disable = function(){\n debug.enable('');\n};\n\n/**\n * Humanize the given `ms`.\n *\n * @param {Number} m\n * @return {String}\n * @api private\n */\n\ndebug.humanize = function(ms) {\n var sec = 1000\n , min = 60 * 1000\n , hour = 60 * min;\n\n if (ms >= hour) return (ms / hour).toFixed(1) + 'h';\n if (ms >= min) return (ms / min).toFixed(1) + 'm';\n if (ms >= sec) return (ms / sec | 0) + 's';\n return ms + 'ms';\n};\n\n/**\n * Returns true if the given mode name is enabled, false otherwise.\n *\n * @param {String} name\n * @return {Boolean}\n * @api public\n */\n\ndebug.enabled = function(name) {\n for (var i = 0, len = debug.skips.length; i < len; i++) {\n if (debug.skips[i].test(name)) {\n return false;\n }\n }\n for (var i = 0, len = debug.names.length; i < len; i++) {\n if (debug.names[i].test(name)) {\n return true;\n }\n }\n return false;\n};\n\n/**\n * Coerce `val`.\n */\n\nfunction coerce(val) {\n if (val instanceof Error) return val.stack || val.message;\n return val;\n}\n\n// persist\n\ntry {\n if (window.localStorage) debug.enable(localStorage.debug);\n} catch(e){}\n\n\n/*****************\n ** WEBPACK FOOTER\n ** (webpack)-dev-server/~/socket.io-client/~/debug/debug.js\n ** module id = 4\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///(webpack)-dev-server/~/socket.io-client/~/debug/debug.js?");
|
||
|
||
/***/ },
|
||
/* 5 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/* WEBPACK VAR INJECTION */(function(global) {\n/**\n * Module dependencies.\n */\n\nvar parseuri = __webpack_require__(6);\nvar debug = __webpack_require__(4)('socket.io-client:url');\n\n/**\n * Module exports.\n */\n\nmodule.exports = url;\n\n/**\n * URL parser.\n *\n * @param {String} url\n * @param {Object} An object meant to mimic window.location.\n * Defaults to window.location.\n * @api public\n */\n\nfunction url(uri, loc){\n var obj = uri;\n\n // default to window.location\n var loc = loc || global.location;\n if (null == uri) uri = loc.protocol + '//' + loc.host;\n\n // relative path support\n if ('string' == typeof uri) {\n if ('/' == uri.charAt(0)) {\n if ('/' == uri.charAt(1)) {\n uri = loc.protocol + uri;\n } else {\n uri = loc.hostname + uri;\n }\n }\n\n if (!/^(https?|wss?):\\/\\//.test(uri)) {\n debug('protocol-less url %s', uri);\n if ('undefined' != typeof loc) {\n uri = loc.protocol + '//' + uri;\n } else {\n uri = 'https://' + uri;\n }\n }\n\n // parse\n debug('parse %s', uri);\n obj = parseuri(uri);\n }\n\n // make sure we treat `localhost:80` and `localhost` equally\n if (!obj.port) {\n if (/^(http|ws)$/.test(obj.protocol)) {\n obj.port = '80';\n }\n else if (/^(http|ws)s$/.test(obj.protocol)) {\n obj.port = '443';\n }\n }\n\n obj.path = obj.path || '/';\n\n // define unique id\n obj.id = obj.protocol + '://' + obj.host + ':' + obj.port;\n // define href\n obj.href = obj.protocol + '://' + obj.host + (loc && loc.port == obj.port ? '' : (':' + obj.port));\n\n return obj;\n}\n\n/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))\n\n/*****************\n ** WEBPACK FOOTER\n ** (webpack)-dev-server/~/socket.io-client/lib/url.js\n ** module id = 5\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///(webpack)-dev-server/~/socket.io-client/lib/url.js?");
|
||
|
||
/***/ },
|
||
/* 6 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("/**\n * Parses an URI\n *\n * @author Steven Levithan <stevenlevithan.com> (MIT license)\n * @api private\n */\n\nvar re = /^(?:(?![^:@]+:[^:@\\/]*@)(http|https|ws|wss):\\/\\/)?((?:(([^:@]*)(?::([^:@]*))?)?@)?((?:[a-f0-9]{0,4}:){2,7}[a-f0-9]{0,4}|[^:\\/?#]*)(?::(\\d*))?)(((\\/(?:[^?#](?![^?#\\/]*\\.[^?#\\/.]+(?:[?#]|$)))*\\/?)?([^?#\\/]*))(?:\\?([^#]*))?(?:#(.*))?)/;\n\nvar parts = [\n 'source', 'protocol', 'authority', 'userInfo', 'user', 'password', 'host'\n , 'port', 'relative', 'path', 'directory', 'file', 'query', 'anchor'\n];\n\nmodule.exports = function parseuri(str) {\n var m = re.exec(str || '')\n , uri = {}\n , i = 14;\n\n while (i--) {\n uri[parts[i]] = m[i] || '';\n }\n\n return uri;\n};\n\n\n/*****************\n ** WEBPACK FOOTER\n ** (webpack)-dev-server/~/socket.io-client/~/parseuri/index.js\n ** module id = 6\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///(webpack)-dev-server/~/socket.io-client/~/parseuri/index.js?");
|
||
|
||
/***/ },
|
||
/* 7 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("\n/**\n * Module dependencies.\n */\n\nvar debug = __webpack_require__(4)('socket.io-parser');\nvar json = __webpack_require__(9);\nvar isArray = __webpack_require__(11);\nvar Emitter = __webpack_require__(8);\nvar binary = __webpack_require__(12);\nvar isBuf = __webpack_require__(13);\n\n/**\n * Protocol version.\n *\n * @api public\n */\n\nexports.protocol = 4;\n\n/**\n * Packet types.\n *\n * @api public\n */\n\nexports.types = [\n 'CONNECT',\n 'DISCONNECT',\n 'EVENT',\n 'BINARY_EVENT',\n 'ACK',\n 'BINARY_ACK',\n 'ERROR'\n];\n\n/**\n * Packet type `connect`.\n *\n * @api public\n */\n\nexports.CONNECT = 0;\n\n/**\n * Packet type `disconnect`.\n *\n * @api public\n */\n\nexports.DISCONNECT = 1;\n\n/**\n * Packet type `event`.\n *\n * @api public\n */\n\nexports.EVENT = 2;\n\n/**\n * Packet type `ack`.\n *\n * @api public\n */\n\nexports.ACK = 3;\n\n/**\n * Packet type `error`.\n *\n * @api public\n */\n\nexports.ERROR = 4;\n\n/**\n * Packet type 'binary event'\n *\n * @api public\n */\n\nexports.BINARY_EVENT = 5;\n\n/**\n * Packet type `binary ack`. For acks with binary arguments.\n *\n * @api public\n */\n\nexports.BINARY_ACK = 6;\n\n/**\n * Encoder constructor.\n *\n * @api public\n */\n\nexports.Encoder = Encoder;\n\n/**\n * Decoder constructor.\n *\n * @api public\n */\n\nexports.Decoder = Decoder;\n\n/**\n * A socket.io Encoder instance\n *\n * @api public\n */\n\nfunction Encoder() {}\n\n/**\n * Encode a packet as a single string if non-binary, or as a\n * buffer sequence, depending on packet type.\n *\n * @param {Object} obj - packet object\n * @param {Function} callback - function to handle encodings (likely engine.write)\n * @return Calls callback with Array of encodings\n * @api public\n */\n\nEncoder.prototype.encode = function(obj, callback){\n debug('encoding packet %j', obj);\n\n if (exports.BINARY_EVENT == obj.type || exports.BINARY_ACK == obj.type) {\n encodeAsBinary(obj, callback);\n }\n else {\n var encoding = encodeAsString(obj);\n callback([encoding]);\n }\n};\n\n/**\n * Encode packet as string.\n *\n * @param {Object} packet\n * @return {String} encoded\n * @api private\n */\n\nfunction encodeAsString(obj) {\n var str = '';\n var nsp = false;\n\n // first is type\n str += obj.type;\n\n // attachments if we have them\n if (exports.BINARY_EVENT == obj.type || exports.BINARY_ACK == obj.type) {\n str += obj.attachments;\n str += '-';\n }\n\n // if we have a namespace other than `/`\n // we append it followed by a comma `,`\n if (obj.nsp && '/' != obj.nsp) {\n nsp = true;\n str += obj.nsp;\n }\n\n // immediately followed by the id\n if (null != obj.id) {\n if (nsp) {\n str += ',';\n nsp = false;\n }\n str += obj.id;\n }\n\n // json data\n if (null != obj.data) {\n if (nsp) str += ',';\n str += json.stringify(obj.data);\n }\n\n debug('encoded %j as %s', obj, str);\n return str;\n}\n\n/**\n * Encode packet as 'buffer sequence' by removing blobs, and\n * deconstructing packet into object with placeholders and\n * a list of buffers.\n *\n * @param {Object} packet\n * @return {Buffer} encoded\n * @api private\n */\n\nfunction encodeAsBinary(obj, callback) {\n\n function writeEncoding(bloblessData) {\n var deconstruction = binary.deconstructPacket(bloblessData);\n var pack = encodeAsString(deconstruction.packet);\n var buffers = deconstruction.buffers;\n\n buffers.unshift(pack); // add packet info to beginning of data list\n callback(buffers); // write all the buffers\n }\n\n binary.removeBlobs(obj, writeEncoding);\n}\n\n/**\n * A socket.io Decoder instance\n *\n * @return {Object} decoder\n * @api public\n */\n\nfunction Decoder() {\n this.reconstructor = null;\n}\n\n/**\n * Mix in `Emitter` with Decoder.\n */\n\nEmitter(Decoder.prototype);\n\n/**\n * Decodes an ecoded packet string into packet JSON.\n *\n * @param {String} obj - encoded packet\n * @return {Object} packet\n * @api public\n */\n\nDecoder.prototype.add = function(obj) {\n var packet;\n if ('string' == typeof obj) {\n packet = decodeString(obj);\n if (exports.BINARY_EVENT == packet.type || exports.BINARY_ACK == packet.type) { // binary packet's json\n this.reconstructor = new BinaryReconstructor(packet);\n\n // no attachments, labeled binary but no binary data to follow\n if (this.reconstructor.reconPack.attachments === 0) {\n this.emit('decoded', packet);\n }\n } else { // non-binary full packet\n this.emit('decoded', packet);\n }\n }\n else if (isBuf(obj) || obj.base64) { // raw binary data\n if (!this.reconstructor) {\n throw new Error('got binary data when not reconstructing a packet');\n } else {\n packet = this.reconstructor.takeBinaryData(obj);\n if (packet) { // received final buffer\n this.reconstructor = null;\n this.emit('decoded', packet);\n }\n }\n }\n else {\n throw new Error('Unknown type: ' + obj);\n }\n};\n\n/**\n * Decode a packet String (JSON data)\n *\n * @param {String} str\n * @return {Object} packet\n * @api private\n */\n\nfunction decodeString(str) {\n var p = {};\n var i = 0;\n\n // look up type\n p.type = Number(str.charAt(0));\n if (null == exports.types[p.type]) return error();\n\n // look up attachments if type binary\n if (exports.BINARY_EVENT == p.type || exports.BINARY_ACK == p.type) {\n var buf = '';\n while (str.charAt(++i) != '-') {\n buf += str.charAt(i);\n if (i == str.length) break;\n }\n if (buf != Number(buf) || str.charAt(i) != '-') {\n throw new Error('Illegal attachments');\n }\n p.attachments = Number(buf);\n }\n\n // look up namespace (if any)\n if ('/' == str.charAt(i + 1)) {\n p.nsp = '';\n while (++i) {\n var c = str.charAt(i);\n if (',' == c) break;\n p.nsp += c;\n if (i == str.length) break;\n }\n } else {\n p.nsp = '/';\n }\n\n // look up id\n var next = str.charAt(i + 1);\n if ('' !== next && Number(next) == next) {\n p.id = '';\n while (++i) {\n var c = str.charAt(i);\n if (null == c || Number(c) != c) {\n --i;\n break;\n }\n p.id += str.charAt(i);\n if (i == str.length) break;\n }\n p.id = Number(p.id);\n }\n\n // look up json data\n if (str.charAt(++i)) {\n try {\n p.data = json.parse(str.substr(i));\n } catch(e){\n return error();\n }\n }\n\n debug('decoded %s as %j', str, p);\n return p;\n}\n\n/**\n * Deallocates a parser's resources\n *\n * @api public\n */\n\nDecoder.prototype.destroy = function() {\n if (this.reconstructor) {\n this.reconstructor.finishedReconstruction();\n }\n};\n\n/**\n * A manager of a binary event's 'buffer sequence'. Should\n * be constructed whenever a packet of type BINARY_EVENT is\n * decoded.\n *\n * @param {Object} packet\n * @return {BinaryReconstructor} initialized reconstructor\n * @api private\n */\n\nfunction BinaryReconstructor(packet) {\n this.reconPack = packet;\n this.buffers = [];\n}\n\n/**\n * Method to be called when binary data received from connection\n * after a BINARY_EVENT packet.\n *\n * @param {Buffer | ArrayBuffer} binData - the raw binary data received\n * @return {null | Object} returns null if more binary data is expected or\n * a reconstructed packet object if all buffers have been received.\n * @api private\n */\n\nBinaryReconstructor.prototype.takeBinaryData = function(binData) {\n this.buffers.push(binData);\n if (this.buffers.length == this.reconPack.attachments) { // done with buffer list\n var packet = binary.reconstructPacket(this.reconPack, this.buffers);\n this.finishedReconstruction();\n return packet;\n }\n return null;\n};\n\n/**\n * Cleans up binary packet reconstruction variables.\n *\n * @api private\n */\n\nBinaryReconstructor.prototype.finishedReconstruction = function() {\n this.reconPack = null;\n this.buffers = [];\n};\n\nfunction error(data){\n return {\n type: exports.ERROR,\n data: 'parser error'\n };\n}\n\n\n/*****************\n ** WEBPACK FOOTER\n ** (webpack)-dev-server/~/socket.io-client/~/socket.io-parser/index.js\n ** module id = 7\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///(webpack)-dev-server/~/socket.io-client/~/socket.io-parser/index.js?");
|
||
|
||
/***/ },
|
||
/* 8 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("\n/**\n * Expose `Emitter`.\n */\n\nmodule.exports = Emitter;\n\n/**\n * Initialize a new `Emitter`.\n *\n * @api public\n */\n\nfunction Emitter(obj) {\n if (obj) return mixin(obj);\n};\n\n/**\n * Mixin the emitter properties.\n *\n * @param {Object} obj\n * @return {Object}\n * @api private\n */\n\nfunction mixin(obj) {\n for (var key in Emitter.prototype) {\n obj[key] = Emitter.prototype[key];\n }\n return obj;\n}\n\n/**\n * Listen on the given `event` with `fn`.\n *\n * @param {String} event\n * @param {Function} fn\n * @return {Emitter}\n * @api public\n */\n\nEmitter.prototype.on =\nEmitter.prototype.addEventListener = function(event, fn){\n this._callbacks = this._callbacks || {};\n (this._callbacks[event] = this._callbacks[event] || [])\n .push(fn);\n return this;\n};\n\n/**\n * Adds an `event` listener that will be invoked a single\n * time then automatically removed.\n *\n * @param {String} event\n * @param {Function} fn\n * @return {Emitter}\n * @api public\n */\n\nEmitter.prototype.once = function(event, fn){\n var self = this;\n this._callbacks = this._callbacks || {};\n\n function on() {\n self.off(event, on);\n fn.apply(this, arguments);\n }\n\n on.fn = fn;\n this.on(event, on);\n return this;\n};\n\n/**\n * Remove the given callback for `event` or all\n * registered callbacks.\n *\n * @param {String} event\n * @param {Function} fn\n * @return {Emitter}\n * @api public\n */\n\nEmitter.prototype.off =\nEmitter.prototype.removeListener =\nEmitter.prototype.removeAllListeners =\nEmitter.prototype.removeEventListener = function(event, fn){\n this._callbacks = this._callbacks || {};\n\n // all\n if (0 == arguments.length) {\n this._callbacks = {};\n return this;\n }\n\n // specific event\n var callbacks = this._callbacks[event];\n if (!callbacks) return this;\n\n // remove all handlers\n if (1 == arguments.length) {\n delete this._callbacks[event];\n return this;\n }\n\n // remove specific handler\n var cb;\n for (var i = 0; i < callbacks.length; i++) {\n cb = callbacks[i];\n if (cb === fn || cb.fn === fn) {\n callbacks.splice(i, 1);\n break;\n }\n }\n return this;\n};\n\n/**\n * Emit `event` with the given args.\n *\n * @param {String} event\n * @param {Mixed} ...\n * @return {Emitter}\n */\n\nEmitter.prototype.emit = function(event){\n this._callbacks = this._callbacks || {};\n var args = [].slice.call(arguments, 1)\n , callbacks = this._callbacks[event];\n\n if (callbacks) {\n callbacks = callbacks.slice(0);\n for (var i = 0, len = callbacks.length; i < len; ++i) {\n callbacks[i].apply(this, args);\n }\n }\n\n return this;\n};\n\n/**\n * Return array of callbacks for `event`.\n *\n * @param {String} event\n * @return {Array}\n * @api public\n */\n\nEmitter.prototype.listeners = function(event){\n this._callbacks = this._callbacks || {};\n return this._callbacks[event] || [];\n};\n\n/**\n * Check if this emitter has `event` handlers.\n *\n * @param {String} event\n * @return {Boolean}\n * @api public\n */\n\nEmitter.prototype.hasListeners = function(event){\n return !! this.listeners(event).length;\n};\n\n\n/*****************\n ** WEBPACK FOOTER\n ** (webpack)-dev-server/~/socket.io-client/~/component-emitter/index.js\n ** module id = 8\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///(webpack)-dev-server/~/socket.io-client/~/component-emitter/index.js?");
|
||
|
||
/***/ },
|
||
/* 9 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("var __WEBPACK_AMD_DEFINE_RESULT__;/*! JSON v3.2.6 | http://bestiejs.github.io/json3 | Copyright 2012-2013, Kit Cambridge | http://kit.mit-license.org */\n;(function (window) {\n // Convenience aliases.\n var getClass = {}.toString, isProperty, forEach, undef;\n\n // Detect the `define` function exposed by asynchronous module loaders. The\n // strict `define` check is necessary for compatibility with `r.js`.\n var isLoader = \"function\" === \"function\" && __webpack_require__(10);\n\n // Detect native implementations.\n var nativeJSON = typeof JSON == \"object\" && JSON;\n\n // Set up the JSON 3 namespace, preferring the CommonJS `exports` object if\n // available.\n var JSON3 = typeof exports == \"object\" && exports && !exports.nodeType && exports;\n\n if (JSON3 && nativeJSON) {\n // Explicitly delegate to the native `stringify` and `parse`\n // implementations in CommonJS environments.\n JSON3.stringify = nativeJSON.stringify;\n JSON3.parse = nativeJSON.parse;\n } else {\n // Export for web browsers, JavaScript engines, and asynchronous module\n // loaders, using the global `JSON` object if available.\n JSON3 = window.JSON = nativeJSON || {};\n }\n\n // Test the `Date#getUTC*` methods. Based on work by @Yaffle.\n var isExtended = new Date(-3509827334573292);\n try {\n // The `getUTCFullYear`, `Month`, and `Date` methods return nonsensical\n // results for certain dates in Opera >= 10.53.\n isExtended = isExtended.getUTCFullYear() == -109252 && isExtended.getUTCMonth() === 0 && isExtended.getUTCDate() === 1 &&\n // Safari < 2.0.2 stores the internal millisecond time value correctly,\n // but clips the values returned by the date methods to the range of\n // signed 32-bit integers ([-2 ** 31, 2 ** 31 - 1]).\n isExtended.getUTCHours() == 10 && isExtended.getUTCMinutes() == 37 && isExtended.getUTCSeconds() == 6 && isExtended.getUTCMilliseconds() == 708;\n } catch (exception) {}\n\n // Internal: Determines whether the native `JSON.stringify` and `parse`\n // implementations are spec-compliant. Based on work by Ken Snyder.\n function has(name) {\n if (has[name] !== undef) {\n // Return cached feature test result.\n return has[name];\n }\n\n var isSupported;\n if (name == \"bug-string-char-index\") {\n // IE <= 7 doesn't support accessing string characters using square\n // bracket notation. IE 8 only supports this for primitives.\n isSupported = \"a\"[0] != \"a\";\n } else if (name == \"json\") {\n // Indicates whether both `JSON.stringify` and `JSON.parse` are\n // supported.\n isSupported = has(\"json-stringify\") && has(\"json-parse\");\n } else {\n var value, serialized = '{\"a\":[1,true,false,null,\"\\\\u0000\\\\b\\\\n\\\\f\\\\r\\\\t\"]}';\n // Test `JSON.stringify`.\n if (name == \"json-stringify\") {\n var stringify = JSON3.stringify, stringifySupported = typeof stringify == \"function\" && isExtended;\n if (stringifySupported) {\n // A test function object with a custom `toJSON` method.\n (value = function () {\n return 1;\n }).toJSON = value;\n try {\n stringifySupported =\n // Firefox 3.1b1 and b2 serialize string, number, and boolean\n // primitives as object literals.\n stringify(0) === \"0\" &&\n // FF 3.1b1, b2, and JSON 2 serialize wrapped primitives as object\n // literals.\n stringify(new Number()) === \"0\" &&\n stringify(new String()) == '\"\"' &&\n // FF 3.1b1, 2 throw an error if the value is `null`, `undefined`, or\n // does not define a canonical JSON representation (this applies to\n // objects with `toJSON` properties as well, *unless* they are nested\n // within an object or array).\n stringify(getClass) === undef &&\n // IE 8 serializes `undefined` as `\"undefined\"`. Safari <= 5.1.7 and\n // FF 3.1b3 pass this test.\n stringify(undef) === undef &&\n // Safari <= 5.1.7 and FF 3.1b3 throw `Error`s and `TypeError`s,\n // respectively, if the value is omitted entirely.\n stringify() === undef &&\n // FF 3.1b1, 2 throw an error if the given value is not a number,\n // string, array, object, Boolean, or `null` literal. This applies to\n // objects with custom `toJSON` methods as well, unless they are nested\n // inside object or array literals. YUI 3.0.0b1 ignores custom `toJSON`\n // methods entirely.\n stringify(value) === \"1\" &&\n stringify([value]) == \"[1]\" &&\n // Prototype <= 1.6.1 serializes `[undefined]` as `\"[]\"` instead of\n // `\"[null]\"`.\n stringify([undef]) == \"[null]\" &&\n // YUI 3.0.0b1 fails to serialize `null` literals.\n stringify(null) == \"null\" &&\n // FF 3.1b1, 2 halts serialization if an array contains a function:\n // `[1, true, getClass, 1]` serializes as \"[1,true,],\". FF 3.1b3\n // elides non-JSON values from objects and arrays, unless they\n // define custom `toJSON` methods.\n stringify([undef, getClass, null]) == \"[null,null,null]\" &&\n // Simple serialization test. FF 3.1b1 uses Unicode escape sequences\n // where character escape codes are expected (e.g., `\\b` => `\\u0008`).\n stringify({ \"a\": [value, true, false, null, \"\\x00\\b\\n\\f\\r\\t\"] }) == serialized &&\n // FF 3.1b1 and b2 ignore the `filter` and `width` arguments.\n stringify(null, value) === \"1\" &&\n stringify([1, 2], null, 1) == \"[\\n 1,\\n 2\\n]\" &&\n // JSON 2, Prototype <= 1.7, and older WebKit builds incorrectly\n // serialize extended years.\n stringify(new Date(-8.64e15)) == '\"-271821-04-20T00:00:00.000Z\"' &&\n // The milliseconds are optional in ES 5, but required in 5.1.\n stringify(new Date(8.64e15)) == '\"+275760-09-13T00:00:00.000Z\"' &&\n // Firefox <= 11.0 incorrectly serializes years prior to 0 as negative\n // four-digit years instead of six-digit years. Credits: @Yaffle.\n stringify(new Date(-621987552e5)) == '\"-000001-01-01T00:00:00.000Z\"' &&\n // Safari <= 5.1.5 and Opera >= 10.53 incorrectly serialize millisecond\n // values less than 1000. Credits: @Yaffle.\n stringify(new Date(-1)) == '\"1969-12-31T23:59:59.999Z\"';\n } catch (exception) {\n stringifySupported = false;\n }\n }\n isSupported = stringifySupported;\n }\n // Test `JSON.parse`.\n if (name == \"json-parse\") {\n var parse = JSON3.parse;\n if (typeof parse == \"function\") {\n try {\n // FF 3.1b1, b2 will throw an exception if a bare literal is provided.\n // Conforming implementations should also coerce the initial argument to\n // a string prior to parsing.\n if (parse(\"0\") === 0 && !parse(false)) {\n // Simple parsing test.\n value = parse(serialized);\n var parseSupported = value[\"a\"].length == 5 && value[\"a\"][0] === 1;\n if (parseSupported) {\n try {\n // Safari <= 5.1.2 and FF 3.1b1 allow unescaped tabs in strings.\n parseSupported = !parse('\"\\t\"');\n } catch (exception) {}\n if (parseSupported) {\n try {\n // FF 4.0 and 4.0.1 allow leading `+` signs and leading\n // decimal points. FF 4.0, 4.0.1, and IE 9-10 also allow\n // certain octal literals.\n parseSupported = parse(\"01\") !== 1;\n } catch (exception) {}\n }\n if (parseSupported) {\n try {\n // FF 4.0, 4.0.1, and Rhino 1.7R3-R4 allow trailing decimal\n // points. These environments, along with FF 3.1b1 and 2,\n // also allow trailing commas in JSON objects and arrays.\n parseSupported = parse(\"1.\") !== 1;\n } catch (exception) {}\n }\n }\n }\n } catch (exception) {\n parseSupported = false;\n }\n }\n isSupported = parseSupported;\n }\n }\n return has[name] = !!isSupported;\n }\n\n if (!has(\"json\")) {\n // Common `[[Class]]` name aliases.\n var functionClass = \"[object Function]\";\n var dateClass = \"[object Date]\";\n var numberClass = \"[object Number]\";\n var stringClass = \"[object String]\";\n var arrayClass = \"[object Array]\";\n var booleanClass = \"[object Boolean]\";\n\n // Detect incomplete support for accessing string characters by index.\n var charIndexBuggy = has(\"bug-string-char-index\");\n\n // Define additional utility methods if the `Date` methods are buggy.\n if (!isExtended) {\n var floor = Math.floor;\n // A mapping between the months of the year and the number of days between\n // January 1st and the first of the respective month.\n var Months = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334];\n // Internal: Calculates the number of days between the Unix epoch and the\n // first day of the given month.\n var getDay = function (year, month) {\n return Months[month] + 365 * (year - 1970) + floor((year - 1969 + (month = +(month > 1))) / 4) - floor((year - 1901 + month) / 100) + floor((year - 1601 + month) / 400);\n };\n }\n\n // Internal: Determines if a property is a direct property of the given\n // object. Delegates to the native `Object#hasOwnProperty` method.\n if (!(isProperty = {}.hasOwnProperty)) {\n isProperty = function (property) {\n var members = {}, constructor;\n if ((members.__proto__ = null, members.__proto__ = {\n // The *proto* property cannot be set multiple times in recent\n // versions of Firefox and SeaMonkey.\n \"toString\": 1\n }, members).toString != getClass) {\n // Safari <= 2.0.3 doesn't implement `Object#hasOwnProperty`, but\n // supports the mutable *proto* property.\n isProperty = function (property) {\n // Capture and break the object's prototype chain (see section 8.6.2\n // of the ES 5.1 spec). The parenthesized expression prevents an\n // unsafe transformation by the Closure Compiler.\n var original = this.__proto__, result = property in (this.__proto__ = null, this);\n // Restore the original prototype chain.\n this.__proto__ = original;\n return result;\n };\n } else {\n // Capture a reference to the top-level `Object` constructor.\n constructor = members.constructor;\n // Use the `constructor` property to simulate `Object#hasOwnProperty` in\n // other environments.\n isProperty = function (property) {\n var parent = (this.constructor || constructor).prototype;\n return property in this && !(property in parent && this[property] === parent[property]);\n };\n }\n members = null;\n return isProperty.call(this, property);\n };\n }\n\n // Internal: A set of primitive types used by `isHostType`.\n var PrimitiveTypes = {\n 'boolean': 1,\n 'number': 1,\n 'string': 1,\n 'undefined': 1\n };\n\n // Internal: Determines if the given object `property` value is a\n // non-primitive.\n var isHostType = function (object, property) {\n var type = typeof object[property];\n return type == 'object' ? !!object[property] : !PrimitiveTypes[type];\n };\n\n // Internal: Normalizes the `for...in` iteration algorithm across\n // environments. Each enumerated key is yielded to a `callback` function.\n forEach = function (object, callback) {\n var size = 0, Properties, members, property;\n\n // Tests for bugs in the current environment's `for...in` algorithm. The\n // `valueOf` property inherits the non-enumerable flag from\n // `Object.prototype` in older versions of IE, Netscape, and Mozilla.\n (Properties = function () {\n this.valueOf = 0;\n }).prototype.valueOf = 0;\n\n // Iterate over a new instance of the `Properties` class.\n members = new Properties();\n for (property in members) {\n // Ignore all properties inherited from `Object.prototype`.\n if (isProperty.call(members, property)) {\n size++;\n }\n }\n Properties = members = null;\n\n // Normalize the iteration algorithm.\n if (!size) {\n // A list of non-enumerable properties inherited from `Object.prototype`.\n members = [\"valueOf\", \"toString\", \"toLocaleString\", \"propertyIsEnumerable\", \"isPrototypeOf\", \"hasOwnProperty\", \"constructor\"];\n // IE <= 8, Mozilla 1.0, and Netscape 6.2 ignore shadowed non-enumerable\n // properties.\n forEach = function (object, callback) {\n var isFunction = getClass.call(object) == functionClass, property, length;\n var hasProperty = !isFunction && typeof object.constructor != 'function' && isHostType(object, 'hasOwnProperty') ? object.hasOwnProperty : isProperty;\n for (property in object) {\n // Gecko <= 1.0 enumerates the `prototype` property of functions under\n // certain conditions; IE does not.\n if (!(isFunction && property == \"prototype\") && hasProperty.call(object, property)) {\n callback(property);\n }\n }\n // Manually invoke the callback for each non-enumerable property.\n for (length = members.length; property = members[--length]; hasProperty.call(object, property) && callback(property));\n };\n } else if (size == 2) {\n // Safari <= 2.0.4 enumerates shadowed properties twice.\n forEach = function (object, callback) {\n // Create a set of iterated properties.\n var members = {}, isFunction = getClass.call(object) == functionClass, property;\n for (property in object) {\n // Store each property name to prevent double enumeration. The\n // `prototype` property of functions is not enumerated due to cross-\n // environment inconsistencies.\n if (!(isFunction && property == \"prototype\") && !isProperty.call(members, property) && (members[property] = 1) && isProperty.call(object, property)) {\n callback(property);\n }\n }\n };\n } else {\n // No bugs detected; use the standard `for...in` algorithm.\n forEach = function (object, callback) {\n var isFunction = getClass.call(object) == functionClass, property, isConstructor;\n for (property in object) {\n if (!(isFunction && property == \"prototype\") && isProperty.call(object, property) && !(isConstructor = property === \"constructor\")) {\n callback(property);\n }\n }\n // Manually invoke the callback for the `constructor` property due to\n // cross-environment inconsistencies.\n if (isConstructor || isProperty.call(object, (property = \"constructor\"))) {\n callback(property);\n }\n };\n }\n return forEach(object, callback);\n };\n\n // Public: Serializes a JavaScript `value` as a JSON string. The optional\n // `filter` argument may specify either a function that alters how object and\n // array members are serialized, or an array of strings and numbers that\n // indicates which properties should be serialized. The optional `width`\n // argument may be either a string or number that specifies the indentation\n // level of the output.\n if (!has(\"json-stringify\")) {\n // Internal: A map of control characters and their escaped equivalents.\n var Escapes = {\n 92: \"\\\\\\\\\",\n 34: '\\\\\"',\n 8: \"\\\\b\",\n 12: \"\\\\f\",\n 10: \"\\\\n\",\n 13: \"\\\\r\",\n 9: \"\\\\t\"\n };\n\n // Internal: Converts `value` into a zero-padded string such that its\n // length is at least equal to `width`. The `width` must be <= 6.\n var leadingZeroes = \"000000\";\n var toPaddedString = function (width, value) {\n // The `|| 0` expression is necessary to work around a bug in\n // Opera <= 7.54u2 where `0 == -0`, but `String(-0) !== \"0\"`.\n return (leadingZeroes + (value || 0)).slice(-width);\n };\n\n // Internal: Double-quotes a string `value`, replacing all ASCII control\n // characters (characters with code unit values between 0 and 31) with\n // their escaped equivalents. This is an implementation of the\n // `Quote(value)` operation defined in ES 5.1 section 15.12.3.\n var unicodePrefix = \"\\\\u00\";\n var quote = function (value) {\n var result = '\"', index = 0, length = value.length, isLarge = length > 10 && charIndexBuggy, symbols;\n if (isLarge) {\n symbols = value.split(\"\");\n }\n for (; index < length; index++) {\n var charCode = value.charCodeAt(index);\n // If the character is a control character, append its Unicode or\n // shorthand escape sequence; otherwise, append the character as-is.\n switch (charCode) {\n case 8: case 9: case 10: case 12: case 13: case 34: case 92:\n result += Escapes[charCode];\n break;\n default:\n if (charCode < 32) {\n result += unicodePrefix + toPaddedString(2, charCode.toString(16));\n break;\n }\n result += isLarge ? symbols[index] : charIndexBuggy ? value.charAt(index) : value[index];\n }\n }\n return result + '\"';\n };\n\n // Internal: Recursively serializes an object. Implements the\n // `Str(key, holder)`, `JO(value)`, and `JA(value)` operations.\n var serialize = function (property, object, callback, properties, whitespace, indentation, stack) {\n var value, className, year, month, date, time, hours, minutes, seconds, milliseconds, results, element, index, length, prefix, result;\n try {\n // Necessary for host object support.\n value = object[property];\n } catch (exception) {}\n if (typeof value == \"object\" && value) {\n className = getClass.call(value);\n if (className == dateClass && !isProperty.call(value, \"toJSON\")) {\n if (value > -1 / 0 && value < 1 / 0) {\n // Dates are serialized according to the `Date#toJSON` method\n // specified in ES 5.1 section 15.9.5.44. See section 15.9.1.15\n // for the ISO 8601 date time string format.\n if (getDay) {\n // Manually compute the year, month, date, hours, minutes,\n // seconds, and milliseconds if the `getUTC*` methods are\n // buggy. Adapted from @Yaffle's `date-shim` project.\n date = floor(value / 864e5);\n for (year = floor(date / 365.2425) + 1970 - 1; getDay(year + 1, 0) <= date; year++);\n for (month = floor((date - getDay(year, 0)) / 30.42); getDay(year, month + 1) <= date; month++);\n date = 1 + date - getDay(year, month);\n // The `time` value specifies the time within the day (see ES\n // 5.1 section 15.9.1.2). The formula `(A % B + B) % B` is used\n // to compute `A modulo B`, as the `%` operator does not\n // correspond to the `modulo` operation for negative numbers.\n time = (value % 864e5 + 864e5) % 864e5;\n // The hours, minutes, seconds, and milliseconds are obtained by\n // decomposing the time within the day. See section 15.9.1.10.\n hours = floor(time / 36e5) % 24;\n minutes = floor(time / 6e4) % 60;\n seconds = floor(time / 1e3) % 60;\n milliseconds = time % 1e3;\n } else {\n year = value.getUTCFullYear();\n month = value.getUTCMonth();\n date = value.getUTCDate();\n hours = value.getUTCHours();\n minutes = value.getUTCMinutes();\n seconds = value.getUTCSeconds();\n milliseconds = value.getUTCMilliseconds();\n }\n // Serialize extended years correctly.\n value = (year <= 0 || year >= 1e4 ? (year < 0 ? \"-\" : \"+\") + toPaddedString(6, year < 0 ? -year : year) : toPaddedString(4, year)) +\n \"-\" + toPaddedString(2, month + 1) + \"-\" + toPaddedString(2, date) +\n // Months, dates, hours, minutes, and seconds should have two\n // digits; milliseconds should have three.\n \"T\" + toPaddedString(2, hours) + \":\" + toPaddedString(2, minutes) + \":\" + toPaddedString(2, seconds) +\n // Milliseconds are optional in ES 5.0, but required in 5.1.\n \".\" + toPaddedString(3, milliseconds) + \"Z\";\n } else {\n value = null;\n }\n } else if (typeof value.toJSON == \"function\" && ((className != numberClass && className != stringClass && className != arrayClass) || isProperty.call(value, \"toJSON\"))) {\n // Prototype <= 1.6.1 adds non-standard `toJSON` methods to the\n // `Number`, `String`, `Date`, and `Array` prototypes. JSON 3\n // ignores all `toJSON` methods on these objects unless they are\n // defined directly on an instance.\n value = value.toJSON(property);\n }\n }\n if (callback) {\n // If a replacement function was provided, call it to obtain the value\n // for serialization.\n value = callback.call(object, property, value);\n }\n if (value === null) {\n return \"null\";\n }\n className = getClass.call(value);\n if (className == booleanClass) {\n // Booleans are represented literally.\n return \"\" + value;\n } else if (className == numberClass) {\n // JSON numbers must be finite. `Infinity` and `NaN` are serialized as\n // `\"null\"`.\n return value > -1 / 0 && value < 1 / 0 ? \"\" + value : \"null\";\n } else if (className == stringClass) {\n // Strings are double-quoted and escaped.\n return quote(\"\" + value);\n }\n // Recursively serialize objects and arrays.\n if (typeof value == \"object\") {\n // Check for cyclic structures. This is a linear search; performance\n // is inversely proportional to the number of unique nested objects.\n for (length = stack.length; length--;) {\n if (stack[length] === value) {\n // Cyclic structures cannot be serialized by `JSON.stringify`.\n throw TypeError();\n }\n }\n // Add the object to the stack of traversed objects.\n stack.push(value);\n results = [];\n // Save the current indentation level and indent one additional level.\n prefix = indentation;\n indentation += whitespace;\n if (className == arrayClass) {\n // Recursively serialize array elements.\n for (index = 0, length = value.length; index < length; index++) {\n element = serialize(index, value, callback, properties, whitespace, indentation, stack);\n results.push(element === undef ? \"null\" : element);\n }\n result = results.length ? (whitespace ? \"[\\n\" + indentation + results.join(\",\\n\" + indentation) + \"\\n\" + prefix + \"]\" : (\"[\" + results.join(\",\") + \"]\")) : \"[]\";\n } else {\n // Recursively serialize object members. Members are selected from\n // either a user-specified list of property names, or the object\n // itself.\n forEach(properties || value, function (property) {\n var element = serialize(property, value, callback, properties, whitespace, indentation, stack);\n if (element !== undef) {\n // According to ES 5.1 section 15.12.3: \"If `gap` {whitespace}\n // is not the empty string, let `member` {quote(property) + \":\"}\n // be the concatenation of `member` and the `space` character.\"\n // The \"`space` character\" refers to the literal space\n // character, not the `space` {width} argument provided to\n // `JSON.stringify`.\n results.push(quote(property) + \":\" + (whitespace ? \" \" : \"\") + element);\n }\n });\n result = results.length ? (whitespace ? \"{\\n\" + indentation + results.join(\",\\n\" + indentation) + \"\\n\" + prefix + \"}\" : (\"{\" + results.join(\",\") + \"}\")) : \"{}\";\n }\n // Remove the object from the traversed object stack.\n stack.pop();\n return result;\n }\n };\n\n // Public: `JSON.stringify`. See ES 5.1 section 15.12.3.\n JSON3.stringify = function (source, filter, width) {\n var whitespace, callback, properties, className;\n if (typeof filter == \"function\" || typeof filter == \"object\" && filter) {\n if ((className = getClass.call(filter)) == functionClass) {\n callback = filter;\n } else if (className == arrayClass) {\n // Convert the property names array into a makeshift set.\n properties = {};\n for (var index = 0, length = filter.length, value; index < length; value = filter[index++], ((className = getClass.call(value)), className == stringClass || className == numberClass) && (properties[value] = 1));\n }\n }\n if (width) {\n if ((className = getClass.call(width)) == numberClass) {\n // Convert the `width` to an integer and create a string containing\n // `width` number of space characters.\n if ((width -= width % 1) > 0) {\n for (whitespace = \"\", width > 10 && (width = 10); whitespace.length < width; whitespace += \" \");\n }\n } else if (className == stringClass) {\n whitespace = width.length <= 10 ? width : width.slice(0, 10);\n }\n }\n // Opera <= 7.54u2 discards the values associated with empty string keys\n // (`\"\"`) only if they are used directly within an object member list\n // (e.g., `!(\"\" in { \"\": 1})`).\n return serialize(\"\", (value = {}, value[\"\"] = source, value), callback, properties, whitespace, \"\", []);\n };\n }\n\n // Public: Parses a JSON source string.\n if (!has(\"json-parse\")) {\n var fromCharCode = String.fromCharCode;\n\n // Internal: A map of escaped control characters and their unescaped\n // equivalents.\n var Unescapes = {\n 92: \"\\\\\",\n 34: '\"',\n 47: \"/\",\n 98: \"\\b\",\n 116: \"\\t\",\n 110: \"\\n\",\n 102: \"\\f\",\n 114: \"\\r\"\n };\n\n // Internal: Stores the parser state.\n var Index, Source;\n\n // Internal: Resets the parser state and throws a `SyntaxError`.\n var abort = function() {\n Index = Source = null;\n throw SyntaxError();\n };\n\n // Internal: Returns the next token, or `\"$\"` if the parser has reached\n // the end of the source string. A token may be a string, number, `null`\n // literal, or Boolean literal.\n var lex = function () {\n var source = Source, length = source.length, value, begin, position, isSigned, charCode;\n while (Index < length) {\n charCode = source.charCodeAt(Index);\n switch (charCode) {\n case 9: case 10: case 13: case 32:\n // Skip whitespace tokens, including tabs, carriage returns, line\n // feeds, and space characters.\n Index++;\n break;\n case 123: case 125: case 91: case 93: case 58: case 44:\n // Parse a punctuator token (`{`, `}`, `[`, `]`, `:`, or `,`) at\n // the current position.\n value = charIndexBuggy ? source.charAt(Index) : source[Index];\n Index++;\n return value;\n case 34:\n // `\"` delimits a JSON string; advance to the next character and\n // begin parsing the string. String tokens are prefixed with the\n // sentinel `@` character to distinguish them from punctuators and\n // end-of-string tokens.\n for (value = \"@\", Index++; Index < length;) {\n charCode = source.charCodeAt(Index);\n if (charCode < 32) {\n // Unescaped ASCII control characters (those with a code unit\n // less than the space character) are not permitted.\n abort();\n } else if (charCode == 92) {\n // A reverse solidus (`\\`) marks the beginning of an escaped\n // control character (including `\"`, `\\`, and `/`) or Unicode\n // escape sequence.\n charCode = source.charCodeAt(++Index);\n switch (charCode) {\n case 92: case 34: case 47: case 98: case 116: case 110: case 102: case 114:\n // Revive escaped control characters.\n value += Unescapes[charCode];\n Index++;\n break;\n case 117:\n // `\\u` marks the beginning of a Unicode escape sequence.\n // Advance to the first character and validate the\n // four-digit code point.\n begin = ++Index;\n for (position = Index + 4; Index < position; Index++) {\n charCode = source.charCodeAt(Index);\n // A valid sequence comprises four hexdigits (case-\n // insensitive) that form a single hexadecimal value.\n if (!(charCode >= 48 && charCode <= 57 || charCode >= 97 && charCode <= 102 || charCode >= 65 && charCode <= 70)) {\n // Invalid Unicode escape sequence.\n abort();\n }\n }\n // Revive the escaped character.\n value += fromCharCode(\"0x\" + source.slice(begin, Index));\n break;\n default:\n // Invalid escape sequence.\n abort();\n }\n } else {\n if (charCode == 34) {\n // An unescaped double-quote character marks the end of the\n // string.\n break;\n }\n charCode = source.charCodeAt(Index);\n begin = Index;\n // Optimize for the common case where a string is valid.\n while (charCode >= 32 && charCode != 92 && charCode != 34) {\n charCode = source.charCodeAt(++Index);\n }\n // Append the string as-is.\n value += source.slice(begin, Index);\n }\n }\n if (source.charCodeAt(Index) == 34) {\n // Advance to the next character and return the revived string.\n Index++;\n return value;\n }\n // Unterminated string.\n abort();\n default:\n // Parse numbers and literals.\n begin = Index;\n // Advance past the negative sign, if one is specified.\n if (charCode == 45) {\n isSigned = true;\n charCode = source.charCodeAt(++Index);\n }\n // Parse an integer or floating-point value.\n if (charCode >= 48 && charCode <= 57) {\n // Leading zeroes are interpreted as octal literals.\n if (charCode == 48 && ((charCode = source.charCodeAt(Index + 1)), charCode >= 48 && charCode <= 57)) {\n // Illegal octal literal.\n abort();\n }\n isSigned = false;\n // Parse the integer component.\n for (; Index < length && ((charCode = source.charCodeAt(Index)), charCode >= 48 && charCode <= 57); Index++);\n // Floats cannot contain a leading decimal point; however, this\n // case is already accounted for by the parser.\n if (source.charCodeAt(Index) == 46) {\n position = ++Index;\n // Parse the decimal component.\n for (; position < length && ((charCode = source.charCodeAt(position)), charCode >= 48 && charCode <= 57); position++);\n if (position == Index) {\n // Illegal trailing decimal.\n abort();\n }\n Index = position;\n }\n // Parse exponents. The `e` denoting the exponent is\n // case-insensitive.\n charCode = source.charCodeAt(Index);\n if (charCode == 101 || charCode == 69) {\n charCode = source.charCodeAt(++Index);\n // Skip past the sign following the exponent, if one is\n // specified.\n if (charCode == 43 || charCode == 45) {\n Index++;\n }\n // Parse the exponential component.\n for (position = Index; position < length && ((charCode = source.charCodeAt(position)), charCode >= 48 && charCode <= 57); position++);\n if (position == Index) {\n // Illegal empty exponent.\n abort();\n }\n Index = position;\n }\n // Coerce the parsed value to a JavaScript number.\n return +source.slice(begin, Index);\n }\n // A negative sign may only precede numbers.\n if (isSigned) {\n abort();\n }\n // `true`, `false`, and `null` literals.\n if (source.slice(Index, Index + 4) == \"true\") {\n Index += 4;\n return true;\n } else if (source.slice(Index, Index + 5) == \"false\") {\n Index += 5;\n return false;\n } else if (source.slice(Index, Index + 4) == \"null\") {\n Index += 4;\n return null;\n }\n // Unrecognized token.\n abort();\n }\n }\n // Return the sentinel `$` character if the parser has reached the end\n // of the source string.\n return \"$\";\n };\n\n // Internal: Parses a JSON `value` token.\n var get = function (value) {\n var results, hasMembers;\n if (value == \"$\") {\n // Unexpected end of input.\n abort();\n }\n if (typeof value == \"string\") {\n if ((charIndexBuggy ? value.charAt(0) : value[0]) == \"@\") {\n // Remove the sentinel `@` character.\n return value.slice(1);\n }\n // Parse object and array literals.\n if (value == \"[\") {\n // Parses a JSON array, returning a new JavaScript array.\n results = [];\n for (;; hasMembers || (hasMembers = true)) {\n value = lex();\n // A closing square bracket marks the end of the array literal.\n if (value == \"]\") {\n break;\n }\n // If the array literal contains elements, the current token\n // should be a comma separating the previous element from the\n // next.\n if (hasMembers) {\n if (value == \",\") {\n value = lex();\n if (value == \"]\") {\n // Unexpected trailing `,` in array literal.\n abort();\n }\n } else {\n // A `,` must separate each array element.\n abort();\n }\n }\n // Elisions and leading commas are not permitted.\n if (value == \",\") {\n abort();\n }\n results.push(get(value));\n }\n return results;\n } else if (value == \"{\") {\n // Parses a JSON object, returning a new JavaScript object.\n results = {};\n for (;; hasMembers || (hasMembers = true)) {\n value = lex();\n // A closing curly brace marks the end of the object literal.\n if (value == \"}\") {\n break;\n }\n // If the object literal contains members, the current token\n // should be a comma separator.\n if (hasMembers) {\n if (value == \",\") {\n value = lex();\n if (value == \"}\") {\n // Unexpected trailing `,` in object literal.\n abort();\n }\n } else {\n // A `,` must separate each object member.\n abort();\n }\n }\n // Leading commas are not permitted, object property names must be\n // double-quoted strings, and a `:` must separate each property\n // name and value.\n if (value == \",\" || typeof value != \"string\" || (charIndexBuggy ? value.charAt(0) : value[0]) != \"@\" || lex() != \":\") {\n abort();\n }\n results[value.slice(1)] = get(lex());\n }\n return results;\n }\n // Unexpected token encountered.\n abort();\n }\n return value;\n };\n\n // Internal: Updates a traversed object member.\n var update = function(source, property, callback) {\n var element = walk(source, property, callback);\n if (element === undef) {\n delete source[property];\n } else {\n source[property] = element;\n }\n };\n\n // Internal: Recursively traverses a parsed JSON object, invoking the\n // `callback` function for each value. This is an implementation of the\n // `Walk(holder, name)` operation defined in ES 5.1 section 15.12.2.\n var walk = function (source, property, callback) {\n var value = source[property], length;\n if (typeof value == \"object\" && value) {\n // `forEach` can't be used to traverse an array in Opera <= 8.54\n // because its `Object#hasOwnProperty` implementation returns `false`\n // for array indices (e.g., `![1, 2, 3].hasOwnProperty(\"0\")`).\n if (getClass.call(value) == arrayClass) {\n for (length = value.length; length--;) {\n update(value, length, callback);\n }\n } else {\n forEach(value, function (property) {\n update(value, property, callback);\n });\n }\n }\n return callback.call(source, property, value);\n };\n\n // Public: `JSON.parse`. See ES 5.1 section 15.12.2.\n JSON3.parse = function (source, callback) {\n var result, value;\n Index = 0;\n Source = \"\" + source;\n result = get(lex());\n // If a JSON string contains multiple tokens, it is invalid.\n if (lex() != \"$\") {\n abort();\n }\n // Reset the parser state.\n Index = Source = null;\n return callback && getClass.call(callback) == functionClass ? walk((value = {}, value[\"\"] = result, value), \"\", callback) : result;\n };\n }\n }\n\n // Export for asynchronous module loaders.\n if (isLoader) {\n !(__WEBPACK_AMD_DEFINE_RESULT__ = function () {\n return JSON3;\n }.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n }\n}(this));\n\n\n/*****************\n ** WEBPACK FOOTER\n ** (webpack)-dev-server/~/socket.io-client/~/socket.io-parser/~/json3/lib/json3.js\n ** module id = 9\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///(webpack)-dev-server/~/socket.io-client/~/socket.io-parser/~/json3/lib/json3.js?");
|
||
|
||
/***/ },
|
||
/* 10 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("/* WEBPACK VAR INJECTION */(function(__webpack_amd_options__) {module.exports = __webpack_amd_options__;\r\n\n/* WEBPACK VAR INJECTION */}.call(exports, {}))\n\n/*****************\n ** WEBPACK FOOTER\n ** (webpack)/buildin/amd-options.js\n ** module id = 10\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///(webpack)/buildin/amd-options.js?");
|
||
|
||
/***/ },
|
||
/* 11 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("module.exports = Array.isArray || function (arr) {\n return Object.prototype.toString.call(arr) == '[object Array]';\n};\n\n\n/*****************\n ** WEBPACK FOOTER\n ** (webpack)-dev-server/~/socket.io-client/~/socket.io-parser/~/isarray/index.js\n ** module id = 11\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///(webpack)-dev-server/~/socket.io-client/~/socket.io-parser/~/isarray/index.js?");
|
||
|
||
/***/ },
|
||
/* 12 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/* WEBPACK VAR INJECTION */(function(global) {/*global Blob,File*/\n\n/**\n * Module requirements\n */\n\nvar isArray = __webpack_require__(11);\nvar isBuf = __webpack_require__(13);\n\n/**\n * Replaces every Buffer | ArrayBuffer in packet with a numbered placeholder.\n * Anything with blobs or files should be fed through removeBlobs before coming\n * here.\n *\n * @param {Object} packet - socket.io event packet\n * @return {Object} with deconstructed packet and list of buffers\n * @api public\n */\n\nexports.deconstructPacket = function(packet){\n var buffers = [];\n var packetData = packet.data;\n\n function _deconstructPacket(data) {\n if (!data) return data;\n\n if (isBuf(data)) {\n var placeholder = { _placeholder: true, num: buffers.length };\n buffers.push(data);\n return placeholder;\n } else if (isArray(data)) {\n var newData = new Array(data.length);\n for (var i = 0; i < data.length; i++) {\n newData[i] = _deconstructPacket(data[i]);\n }\n return newData;\n } else if ('object' == typeof data && !(data instanceof Date)) {\n var newData = {};\n for (var key in data) {\n newData[key] = _deconstructPacket(data[key]);\n }\n return newData;\n }\n return data;\n }\n\n var pack = packet;\n pack.data = _deconstructPacket(packetData);\n pack.attachments = buffers.length; // number of binary 'attachments'\n return {packet: pack, buffers: buffers};\n};\n\n/**\n * Reconstructs a binary packet from its placeholder packet and buffers\n *\n * @param {Object} packet - event packet with placeholders\n * @param {Array} buffers - binary buffers to put in placeholder positions\n * @return {Object} reconstructed packet\n * @api public\n */\n\nexports.reconstructPacket = function(packet, buffers) {\n var curPlaceHolder = 0;\n\n function _reconstructPacket(data) {\n if (data && data._placeholder) {\n var buf = buffers[data.num]; // appropriate buffer (should be natural order anyway)\n return buf;\n } else if (isArray(data)) {\n for (var i = 0; i < data.length; i++) {\n data[i] = _reconstructPacket(data[i]);\n }\n return data;\n } else if (data && 'object' == typeof data) {\n for (var key in data) {\n data[key] = _reconstructPacket(data[key]);\n }\n return data;\n }\n return data;\n }\n\n packet.data = _reconstructPacket(packet.data);\n packet.attachments = undefined; // no longer useful\n return packet;\n};\n\n/**\n * Asynchronously removes Blobs or Files from data via\n * FileReader's readAsArrayBuffer method. Used before encoding\n * data as msgpack. Calls callback with the blobless data.\n *\n * @param {Object} data\n * @param {Function} callback\n * @api private\n */\n\nexports.removeBlobs = function(data, callback) {\n function _removeBlobs(obj, curKey, containingObject) {\n if (!obj) return obj;\n\n // convert any blob\n if ((global.Blob && obj instanceof Blob) ||\n (global.File && obj instanceof File)) {\n pendingBlobs++;\n\n // async filereader\n var fileReader = new FileReader();\n fileReader.onload = function() { // this.result == arraybuffer\n if (containingObject) {\n containingObject[curKey] = this.result;\n }\n else {\n bloblessData = this.result;\n }\n\n // if nothing pending its callback time\n if(! --pendingBlobs) {\n callback(bloblessData);\n }\n };\n\n fileReader.readAsArrayBuffer(obj); // blob -> arraybuffer\n } else if (isArray(obj)) { // handle array\n for (var i = 0; i < obj.length; i++) {\n _removeBlobs(obj[i], i, obj);\n }\n } else if (obj && 'object' == typeof obj && !isBuf(obj)) { // and object\n for (var key in obj) {\n _removeBlobs(obj[key], key, obj);\n }\n }\n }\n\n var pendingBlobs = 0;\n var bloblessData = data;\n _removeBlobs(bloblessData);\n if (!pendingBlobs) {\n callback(bloblessData);\n }\n};\n\n/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))\n\n/*****************\n ** WEBPACK FOOTER\n ** (webpack)-dev-server/~/socket.io-client/~/socket.io-parser/binary.js\n ** module id = 12\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///(webpack)-dev-server/~/socket.io-client/~/socket.io-parser/binary.js?");
|
||
|
||
/***/ },
|
||
/* 13 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("/* WEBPACK VAR INJECTION */(function(global) {\nmodule.exports = isBuf;\n\n/**\n * Returns true if obj is a buffer or an arraybuffer.\n *\n * @api private\n */\n\nfunction isBuf(obj) {\n return (global.Buffer && global.Buffer.isBuffer(obj)) ||\n (global.ArrayBuffer && obj instanceof ArrayBuffer);\n}\n\n/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))\n\n/*****************\n ** WEBPACK FOOTER\n ** (webpack)-dev-server/~/socket.io-client/~/socket.io-parser/is-buffer.js\n ** module id = 13\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///(webpack)-dev-server/~/socket.io-client/~/socket.io-parser/is-buffer.js?");
|
||
|
||
/***/ },
|
||
/* 14 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("\n/**\n * Module dependencies.\n */\n\nvar url = __webpack_require__(5);\nvar eio = __webpack_require__(15);\nvar Socket = __webpack_require__(46);\nvar Emitter = __webpack_require__(8);\nvar parser = __webpack_require__(7);\nvar on = __webpack_require__(48);\nvar bind = __webpack_require__(49);\nvar object = __webpack_require__(52);\nvar debug = __webpack_require__(4)('socket.io-client:manager');\nvar indexOf = __webpack_require__(43);\nvar Backoff = __webpack_require__(53);\n\n/**\n * Module exports\n */\n\nmodule.exports = Manager;\n\n/**\n * `Manager` constructor.\n *\n * @param {String} engine instance or engine uri/opts\n * @param {Object} options\n * @api public\n */\n\nfunction Manager(uri, opts){\n if (!(this instanceof Manager)) return new Manager(uri, opts);\n if (uri && ('object' == typeof uri)) {\n opts = uri;\n uri = undefined;\n }\n opts = opts || {};\n\n opts.path = opts.path || '/socket.io';\n this.nsps = {};\n this.subs = [];\n this.opts = opts;\n this.reconnection(opts.reconnection !== false);\n this.reconnectionAttempts(opts.reconnectionAttempts || Infinity);\n this.reconnectionDelay(opts.reconnectionDelay || 1000);\n this.reconnectionDelayMax(opts.reconnectionDelayMax || 5000);\n this.randomizationFactor(opts.randomizationFactor || 0.5);\n this.backoff = new Backoff({\n min: this.reconnectionDelay(),\n max: this.reconnectionDelayMax(),\n jitter: this.randomizationFactor()\n });\n this.timeout(null == opts.timeout ? 20000 : opts.timeout);\n this.readyState = 'closed';\n this.uri = uri;\n this.connected = [];\n this.encoding = false;\n this.packetBuffer = [];\n this.encoder = new parser.Encoder();\n this.decoder = new parser.Decoder();\n this.autoConnect = opts.autoConnect !== false;\n if (this.autoConnect) this.open();\n}\n\n/**\n * Propagate given event to sockets and emit on `this`\n *\n * @api private\n */\n\nManager.prototype.emitAll = function() {\n this.emit.apply(this, arguments);\n for (var nsp in this.nsps) {\n this.nsps[nsp].emit.apply(this.nsps[nsp], arguments);\n }\n};\n\n/**\n * Update `socket.id` of all sockets\n *\n * @api private\n */\n\nManager.prototype.updateSocketIds = function(){\n for (var nsp in this.nsps) {\n this.nsps[nsp].id = this.engine.id;\n }\n};\n\n/**\n * Mix in `Emitter`.\n */\n\nEmitter(Manager.prototype);\n\n/**\n * Sets the `reconnection` config.\n *\n * @param {Boolean} true/false if it should automatically reconnect\n * @return {Manager} self or value\n * @api public\n */\n\nManager.prototype.reconnection = function(v){\n if (!arguments.length) return this._reconnection;\n this._reconnection = !!v;\n return this;\n};\n\n/**\n * Sets the reconnection attempts config.\n *\n * @param {Number} max reconnection attempts before giving up\n * @return {Manager} self or value\n * @api public\n */\n\nManager.prototype.reconnectionAttempts = function(v){\n if (!arguments.length) return this._reconnectionAttempts;\n this._reconnectionAttempts = v;\n return this;\n};\n\n/**\n * Sets the delay between reconnections.\n *\n * @param {Number} delay\n * @return {Manager} self or value\n * @api public\n */\n\nManager.prototype.reconnectionDelay = function(v){\n if (!arguments.length) return this._reconnectionDelay;\n this._reconnectionDelay = v;\n this.backoff && this.backoff.setMin(v);\n return this;\n};\n\nManager.prototype.randomizationFactor = function(v){\n if (!arguments.length) return this._randomizationFactor;\n this._randomizationFactor = v;\n this.backoff && this.backoff.setJitter(v);\n return this;\n};\n\n/**\n * Sets the maximum delay between reconnections.\n *\n * @param {Number} delay\n * @return {Manager} self or value\n * @api public\n */\n\nManager.prototype.reconnectionDelayMax = function(v){\n if (!arguments.length) return this._reconnectionDelayMax;\n this._reconnectionDelayMax = v;\n this.backoff && this.backoff.setMax(v);\n return this;\n};\n\n/**\n * Sets the connection timeout. `false` to disable\n *\n * @return {Manager} self or value\n * @api public\n */\n\nManager.prototype.timeout = function(v){\n if (!arguments.length) return this._timeout;\n this._timeout = v;\n return this;\n};\n\n/**\n * Starts trying to reconnect if reconnection is enabled and we have not\n * started reconnecting yet\n *\n * @api private\n */\n\nManager.prototype.maybeReconnectOnOpen = function() {\n // Only try to reconnect if it's the first time we're connecting\n if (!this.reconnecting && this._reconnection && this.backoff.attempts === 0) {\n // keeps reconnection from firing twice for the same reconnection loop\n this.reconnect();\n }\n};\n\n\n/**\n * Sets the current transport `socket`.\n *\n * @param {Function} optional, callback\n * @return {Manager} self\n * @api public\n */\n\nManager.prototype.open =\nManager.prototype.connect = function(fn){\n debug('readyState %s', this.readyState);\n if (~this.readyState.indexOf('open')) return this;\n\n debug('opening %s', this.uri);\n this.engine = eio(this.uri, this.opts);\n var socket = this.engine;\n var self = this;\n this.readyState = 'opening';\n this.skipReconnect = false;\n\n // emit `open`\n var openSub = on(socket, 'open', function() {\n self.onopen();\n fn && fn();\n });\n\n // emit `connect_error`\n var errorSub = on(socket, 'error', function(data){\n debug('connect_error');\n self.cleanup();\n self.readyState = 'closed';\n self.emitAll('connect_error', data);\n if (fn) {\n var err = new Error('Connection error');\n err.data = data;\n fn(err);\n } else {\n // Only do this if there is no fn to handle the error\n self.maybeReconnectOnOpen();\n }\n });\n\n // emit `connect_timeout`\n if (false !== this._timeout) {\n var timeout = this._timeout;\n debug('connect attempt will timeout after %d', timeout);\n\n // set timer\n var timer = setTimeout(function(){\n debug('connect attempt timed out after %d', timeout);\n openSub.destroy();\n socket.close();\n socket.emit('error', 'timeout');\n self.emitAll('connect_timeout', timeout);\n }, timeout);\n\n this.subs.push({\n destroy: function(){\n clearTimeout(timer);\n }\n });\n }\n\n this.subs.push(openSub);\n this.subs.push(errorSub);\n\n return this;\n};\n\n/**\n * Called upon transport open.\n *\n * @api private\n */\n\nManager.prototype.onopen = function(){\n debug('open');\n\n // clear old subs\n this.cleanup();\n\n // mark as open\n this.readyState = 'open';\n this.emit('open');\n\n // add new subs\n var socket = this.engine;\n this.subs.push(on(socket, 'data', bind(this, 'ondata')));\n this.subs.push(on(this.decoder, 'decoded', bind(this, 'ondecoded')));\n this.subs.push(on(socket, 'error', bind(this, 'onerror')));\n this.subs.push(on(socket, 'close', bind(this, 'onclose')));\n};\n\n/**\n * Called with data.\n *\n * @api private\n */\n\nManager.prototype.ondata = function(data){\n this.decoder.add(data);\n};\n\n/**\n * Called when parser fully decodes a packet.\n *\n * @api private\n */\n\nManager.prototype.ondecoded = function(packet) {\n this.emit('packet', packet);\n};\n\n/**\n * Called upon socket error.\n *\n * @api private\n */\n\nManager.prototype.onerror = function(err){\n debug('error', err);\n this.emitAll('error', err);\n};\n\n/**\n * Creates a new socket for the given `nsp`.\n *\n * @return {Socket}\n * @api public\n */\n\nManager.prototype.socket = function(nsp){\n var socket = this.nsps[nsp];\n if (!socket) {\n socket = new Socket(this, nsp);\n this.nsps[nsp] = socket;\n var self = this;\n socket.on('connect', function(){\n socket.id = self.engine.id;\n if (!~indexOf(self.connected, socket)) {\n self.connected.push(socket);\n }\n });\n }\n return socket;\n};\n\n/**\n * Called upon a socket close.\n *\n * @param {Socket} socket\n */\n\nManager.prototype.destroy = function(socket){\n var index = indexOf(this.connected, socket);\n if (~index) this.connected.splice(index, 1);\n if (this.connected.length) return;\n\n this.close();\n};\n\n/**\n * Writes a packet.\n *\n * @param {Object} packet\n * @api private\n */\n\nManager.prototype.packet = function(packet){\n debug('writing packet %j', packet);\n var self = this;\n\n if (!self.encoding) {\n // encode, then write to engine with result\n self.encoding = true;\n this.encoder.encode(packet, function(encodedPackets) {\n for (var i = 0; i < encodedPackets.length; i++) {\n self.engine.write(encodedPackets[i]);\n }\n self.encoding = false;\n self.processPacketQueue();\n });\n } else { // add packet to the queue\n self.packetBuffer.push(packet);\n }\n};\n\n/**\n * If packet buffer is non-empty, begins encoding the\n * next packet in line.\n *\n * @api private\n */\n\nManager.prototype.processPacketQueue = function() {\n if (this.packetBuffer.length > 0 && !this.encoding) {\n var pack = this.packetBuffer.shift();\n this.packet(pack);\n }\n};\n\n/**\n * Clean up transport subscriptions and packet buffer.\n *\n * @api private\n */\n\nManager.prototype.cleanup = function(){\n var sub;\n while (sub = this.subs.shift()) sub.destroy();\n\n this.packetBuffer = [];\n this.encoding = false;\n\n this.decoder.destroy();\n};\n\n/**\n * Close the current socket.\n *\n * @api private\n */\n\nManager.prototype.close =\nManager.prototype.disconnect = function(){\n this.skipReconnect = true;\n this.backoff.reset();\n this.readyState = 'closed';\n this.engine && this.engine.close();\n};\n\n/**\n * Called upon engine close.\n *\n * @api private\n */\n\nManager.prototype.onclose = function(reason){\n debug('close');\n this.cleanup();\n this.backoff.reset();\n this.readyState = 'closed';\n this.emit('close', reason);\n if (this._reconnection && !this.skipReconnect) {\n this.reconnect();\n }\n};\n\n/**\n * Attempt a reconnection.\n *\n * @api private\n */\n\nManager.prototype.reconnect = function(){\n if (this.reconnecting || this.skipReconnect) return this;\n\n var self = this;\n\n if (this.backoff.attempts >= this._reconnectionAttempts) {\n debug('reconnect failed');\n this.backoff.reset();\n this.emitAll('reconnect_failed');\n this.reconnecting = false;\n } else {\n var delay = this.backoff.duration();\n debug('will wait %dms before reconnect attempt', delay);\n\n this.reconnecting = true;\n var timer = setTimeout(function(){\n if (self.skipReconnect) return;\n\n debug('attempting reconnect');\n self.emitAll('reconnect_attempt', self.backoff.attempts);\n self.emitAll('reconnecting', self.backoff.attempts);\n\n // check again for the case socket closed in above events\n if (self.skipReconnect) return;\n\n self.open(function(err){\n if (err) {\n debug('reconnect attempt error');\n self.reconnecting = false;\n self.reconnect();\n self.emitAll('reconnect_error', err.data);\n } else {\n debug('reconnect success');\n self.onreconnect();\n }\n });\n }, delay);\n\n this.subs.push({\n destroy: function(){\n clearTimeout(timer);\n }\n });\n }\n};\n\n/**\n * Called upon successful reconnect.\n *\n * @api private\n */\n\nManager.prototype.onreconnect = function(){\n var attempt = this.backoff.attempts;\n this.reconnecting = false;\n this.backoff.reset();\n this.updateSocketIds();\n this.emitAll('reconnect', attempt);\n};\n\n\n/*****************\n ** WEBPACK FOOTER\n ** (webpack)-dev-server/~/socket.io-client/lib/manager.js\n ** module id = 14\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///(webpack)-dev-server/~/socket.io-client/lib/manager.js?");
|
||
|
||
/***/ },
|
||
/* 15 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("\nmodule.exports = __webpack_require__(16);\n\n\n/*****************\n ** WEBPACK FOOTER\n ** (webpack)-dev-server/~/socket.io-client/~/engine.io-client/index.js\n ** module id = 15\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///(webpack)-dev-server/~/socket.io-client/~/engine.io-client/index.js?");
|
||
|
||
/***/ },
|
||
/* 16 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("\nmodule.exports = __webpack_require__(17);\n\n/**\n * Exports parser\n *\n * @api public\n *\n */\nmodule.exports.parser = __webpack_require__(26);\n\n\n/*****************\n ** WEBPACK FOOTER\n ** (webpack)-dev-server/~/socket.io-client/~/engine.io-client/lib/index.js\n ** module id = 16\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///(webpack)-dev-server/~/socket.io-client/~/engine.io-client/lib/index.js?");
|
||
|
||
/***/ },
|
||
/* 17 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/* WEBPACK VAR INJECTION */(function(global) {/**\n * Module dependencies.\n */\n\nvar transports = __webpack_require__(18);\nvar Emitter = __webpack_require__(8);\nvar debug = __webpack_require__(37)('engine.io-client:socket');\nvar index = __webpack_require__(43);\nvar parser = __webpack_require__(26);\nvar parseuri = __webpack_require__(44);\nvar parsejson = __webpack_require__(45);\nvar parseqs = __webpack_require__(36);\n\n/**\n * Module exports.\n */\n\nmodule.exports = Socket;\n\n/**\n * Noop function.\n *\n * @api private\n */\n\nfunction noop(){}\n\n/**\n * Socket constructor.\n *\n * @param {String|Object} uri or options\n * @param {Object} options\n * @api public\n */\n\nfunction Socket(uri, opts){\n if (!(this instanceof Socket)) return new Socket(uri, opts);\n\n opts = opts || {};\n\n if (uri && 'object' == typeof uri) {\n opts = uri;\n uri = null;\n }\n\n if (uri) {\n uri = parseuri(uri);\n opts.host = uri.host;\n opts.secure = uri.protocol == 'https' || uri.protocol == 'wss';\n opts.port = uri.port;\n if (uri.query) opts.query = uri.query;\n }\n\n this.secure = null != opts.secure ? opts.secure :\n (global.location && 'https:' == location.protocol);\n\n if (opts.host) {\n var pieces = opts.host.split(':');\n opts.hostname = pieces.shift();\n if (pieces.length) {\n opts.port = pieces.pop();\n } else if (!opts.port) {\n // if no port is specified manually, use the protocol default\n opts.port = this.secure ? '443' : '80';\n }\n }\n\n this.agent = opts.agent || false;\n this.hostname = opts.hostname ||\n (global.location ? location.hostname : 'localhost');\n this.port = opts.port || (global.location && location.port ?\n location.port :\n (this.secure ? 443 : 80));\n this.query = opts.query || {};\n if ('string' == typeof this.query) this.query = parseqs.decode(this.query);\n this.upgrade = false !== opts.upgrade;\n this.path = (opts.path || '/engine.io').replace(/\\/$/, '') + '/';\n this.forceJSONP = !!opts.forceJSONP;\n this.jsonp = false !== opts.jsonp;\n this.forceBase64 = !!opts.forceBase64;\n this.enablesXDR = !!opts.enablesXDR;\n this.timestampParam = opts.timestampParam || 't';\n this.timestampRequests = opts.timestampRequests;\n this.transports = opts.transports || ['polling', 'websocket'];\n this.readyState = '';\n this.writeBuffer = [];\n this.callbackBuffer = [];\n this.policyPort = opts.policyPort || 843;\n this.rememberUpgrade = opts.rememberUpgrade || false;\n this.binaryType = null;\n this.onlyBinaryUpgrades = opts.onlyBinaryUpgrades;\n\n // SSL options for Node.js client\n this.pfx = opts.pfx || null;\n this.key = opts.key || null;\n this.passphrase = opts.passphrase || null;\n this.cert = opts.cert || null;\n this.ca = opts.ca || null;\n this.ciphers = opts.ciphers || null;\n this.rejectUnauthorized = opts.rejectUnauthorized || null;\n\n this.open();\n}\n\nSocket.priorWebsocketSuccess = false;\n\n/**\n * Mix in `Emitter`.\n */\n\nEmitter(Socket.prototype);\n\n/**\n * Protocol version.\n *\n * @api public\n */\n\nSocket.protocol = parser.protocol; // this is an int\n\n/**\n * Expose deps for legacy compatibility\n * and standalone browser access.\n */\n\nSocket.Socket = Socket;\nSocket.Transport = __webpack_require__(25);\nSocket.transports = __webpack_require__(18);\nSocket.parser = __webpack_require__(26);\n\n/**\n * Creates transport of the given type.\n *\n * @param {String} transport name\n * @return {Transport}\n * @api private\n */\n\nSocket.prototype.createTransport = function (name) {\n debug('creating transport \"%s\"', name);\n var query = clone(this.query);\n\n // append engine.io protocol identifier\n query.EIO = parser.protocol;\n\n // transport name\n query.transport = name;\n\n // session id if we already have one\n if (this.id) query.sid = this.id;\n\n var transport = new transports[name]({\n agent: this.agent,\n hostname: this.hostname,\n port: this.port,\n secure: this.secure,\n path: this.path,\n query: query,\n forceJSONP: this.forceJSONP,\n jsonp: this.jsonp,\n forceBase64: this.forceBase64,\n enablesXDR: this.enablesXDR,\n timestampRequests: this.timestampRequests,\n timestampParam: this.timestampParam,\n policyPort: this.policyPort,\n socket: this,\n pfx: this.pfx,\n key: this.key,\n passphrase: this.passphrase,\n cert: this.cert,\n ca: this.ca,\n ciphers: this.ciphers,\n rejectUnauthorized: this.rejectUnauthorized\n });\n\n return transport;\n};\n\nfunction clone (obj) {\n var o = {};\n for (var i in obj) {\n if (obj.hasOwnProperty(i)) {\n o[i] = obj[i];\n }\n }\n return o;\n}\n\n/**\n * Initializes transport to use and starts probe.\n *\n * @api private\n */\nSocket.prototype.open = function () {\n var transport;\n if (this.rememberUpgrade && Socket.priorWebsocketSuccess && this.transports.indexOf('websocket') != -1) {\n transport = 'websocket';\n } else if (0 == this.transports.length) {\n // Emit error on next tick so it can be listened to\n var self = this;\n setTimeout(function() {\n self.emit('error', 'No transports available');\n }, 0);\n return;\n } else {\n transport = this.transports[0];\n }\n this.readyState = 'opening';\n\n // Retry with the next transport if the transport is disabled (jsonp: false)\n var transport;\n try {\n transport = this.createTransport(transport);\n } catch (e) {\n this.transports.shift();\n this.open();\n return;\n }\n\n transport.open();\n this.setTransport(transport);\n};\n\n/**\n * Sets the current transport. Disables the existing one (if any).\n *\n * @api private\n */\n\nSocket.prototype.setTransport = function(transport){\n debug('setting transport %s', transport.name);\n var self = this;\n\n if (this.transport) {\n debug('clearing existing transport %s', this.transport.name);\n this.transport.removeAllListeners();\n }\n\n // set up transport\n this.transport = transport;\n\n // set up transport listeners\n transport\n .on('drain', function(){\n self.onDrain();\n })\n .on('packet', function(packet){\n self.onPacket(packet);\n })\n .on('error', function(e){\n self.onError(e);\n })\n .on('close', function(){\n self.onClose('transport close');\n });\n};\n\n/**\n * Probes a transport.\n *\n * @param {String} transport name\n * @api private\n */\n\nSocket.prototype.probe = function (name) {\n debug('probing transport \"%s\"', name);\n var transport = this.createTransport(name, { probe: 1 })\n , failed = false\n , self = this;\n\n Socket.priorWebsocketSuccess = false;\n\n function onTransportOpen(){\n if (self.onlyBinaryUpgrades) {\n var upgradeLosesBinary = !this.supportsBinary && self.transport.supportsBinary;\n failed = failed || upgradeLosesBinary;\n }\n if (failed) return;\n\n debug('probe transport \"%s\" opened', name);\n transport.send([{ type: 'ping', data: 'probe' }]);\n transport.once('packet', function (msg) {\n if (failed) return;\n if ('pong' == msg.type && 'probe' == msg.data) {\n debug('probe transport \"%s\" pong', name);\n self.upgrading = true;\n self.emit('upgrading', transport);\n if (!transport) return;\n Socket.priorWebsocketSuccess = 'websocket' == transport.name;\n\n debug('pausing current transport \"%s\"', self.transport.name);\n self.transport.pause(function () {\n if (failed) return;\n if ('closed' == self.readyState) return;\n debug('changing transport and sending upgrade packet');\n\n cleanup();\n\n self.setTransport(transport);\n transport.send([{ type: 'upgrade' }]);\n self.emit('upgrade', transport);\n transport = null;\n self.upgrading = false;\n self.flush();\n });\n } else {\n debug('probe transport \"%s\" failed', name);\n var err = new Error('probe error');\n err.transport = transport.name;\n self.emit('upgradeError', err);\n }\n });\n }\n\n function freezeTransport() {\n if (failed) return;\n\n // Any callback called by transport should be ignored since now\n failed = true;\n\n cleanup();\n\n transport.close();\n transport = null;\n }\n\n //Handle any error that happens while probing\n function onerror(err) {\n var error = new Error('probe error: ' + err);\n error.transport = transport.name;\n\n freezeTransport();\n\n debug('probe transport \"%s\" failed because of error: %s', name, err);\n\n self.emit('upgradeError', error);\n }\n\n function onTransportClose(){\n onerror(\"transport closed\");\n }\n\n //When the socket is closed while we're probing\n function onclose(){\n onerror(\"socket closed\");\n }\n\n //When the socket is upgraded while we're probing\n function onupgrade(to){\n if (transport && to.name != transport.name) {\n debug('\"%s\" works - aborting \"%s\"', to.name, transport.name);\n freezeTransport();\n }\n }\n\n //Remove all listeners on the transport and on self\n function cleanup(){\n transport.removeListener('open', onTransportOpen);\n transport.removeListener('error', onerror);\n transport.removeListener('close', onTransportClose);\n self.removeListener('close', onclose);\n self.removeListener('upgrading', onupgrade);\n }\n\n transport.once('open', onTransportOpen);\n transport.once('error', onerror);\n transport.once('close', onTransportClose);\n\n this.once('close', onclose);\n this.once('upgrading', onupgrade);\n\n transport.open();\n\n};\n\n/**\n * Called when connection is deemed open.\n *\n * @api public\n */\n\nSocket.prototype.onOpen = function () {\n debug('socket open');\n this.readyState = 'open';\n Socket.priorWebsocketSuccess = 'websocket' == this.transport.name;\n this.emit('open');\n this.flush();\n\n // we check for `readyState` in case an `open`\n // listener already closed the socket\n if ('open' == this.readyState && this.upgrade && this.transport.pause) {\n debug('starting upgrade probes');\n for (var i = 0, l = this.upgrades.length; i < l; i++) {\n this.probe(this.upgrades[i]);\n }\n }\n};\n\n/**\n * Handles a packet.\n *\n * @api private\n */\n\nSocket.prototype.onPacket = function (packet) {\n if ('opening' == this.readyState || 'open' == this.readyState) {\n debug('socket receive: type \"%s\", data \"%s\"', packet.type, packet.data);\n\n this.emit('packet', packet);\n\n // Socket is live - any packet counts\n this.emit('heartbeat');\n\n switch (packet.type) {\n case 'open':\n this.onHandshake(parsejson(packet.data));\n break;\n\n case 'pong':\n this.setPing();\n break;\n\n case 'error':\n var err = new Error('server error');\n err.code = packet.data;\n this.emit('error', err);\n break;\n\n case 'message':\n this.emit('data', packet.data);\n this.emit('message', packet.data);\n break;\n }\n } else {\n debug('packet received with socket readyState \"%s\"', this.readyState);\n }\n};\n\n/**\n * Called upon handshake completion.\n *\n * @param {Object} handshake obj\n * @api private\n */\n\nSocket.prototype.onHandshake = function (data) {\n this.emit('handshake', data);\n this.id = data.sid;\n this.transport.query.sid = data.sid;\n this.upgrades = this.filterUpgrades(data.upgrades);\n this.pingInterval = data.pingInterval;\n this.pingTimeout = data.pingTimeout;\n this.onOpen();\n // In case open handler closes socket\n if ('closed' == this.readyState) return;\n this.setPing();\n\n // Prolong liveness of socket on heartbeat\n this.removeListener('heartbeat', this.onHeartbeat);\n this.on('heartbeat', this.onHeartbeat);\n};\n\n/**\n * Resets ping timeout.\n *\n * @api private\n */\n\nSocket.prototype.onHeartbeat = function (timeout) {\n clearTimeout(this.pingTimeoutTimer);\n var self = this;\n self.pingTimeoutTimer = setTimeout(function () {\n if ('closed' == self.readyState) return;\n self.onClose('ping timeout');\n }, timeout || (self.pingInterval + self.pingTimeout));\n};\n\n/**\n * Pings server every `this.pingInterval` and expects response\n * within `this.pingTimeout` or closes connection.\n *\n * @api private\n */\n\nSocket.prototype.setPing = function () {\n var self = this;\n clearTimeout(self.pingIntervalTimer);\n self.pingIntervalTimer = setTimeout(function () {\n debug('writing ping packet - expecting pong within %sms', self.pingTimeout);\n self.ping();\n self.onHeartbeat(self.pingTimeout);\n }, self.pingInterval);\n};\n\n/**\n* Sends a ping packet.\n*\n* @api public\n*/\n\nSocket.prototype.ping = function () {\n this.sendPacket('ping');\n};\n\n/**\n * Called on `drain` event\n *\n * @api private\n */\n\nSocket.prototype.onDrain = function() {\n for (var i = 0; i < this.prevBufferLen; i++) {\n if (this.callbackBuffer[i]) {\n this.callbackBuffer[i]();\n }\n }\n\n this.writeBuffer.splice(0, this.prevBufferLen);\n this.callbackBuffer.splice(0, this.prevBufferLen);\n\n // setting prevBufferLen = 0 is very important\n // for example, when upgrading, upgrade packet is sent over,\n // and a nonzero prevBufferLen could cause problems on `drain`\n this.prevBufferLen = 0;\n\n if (this.writeBuffer.length == 0) {\n this.emit('drain');\n } else {\n this.flush();\n }\n};\n\n/**\n * Flush write buffers.\n *\n * @api private\n */\n\nSocket.prototype.flush = function () {\n if ('closed' != this.readyState && this.transport.writable &&\n !this.upgrading && this.writeBuffer.length) {\n debug('flushing %d packets in socket', this.writeBuffer.length);\n this.transport.send(this.writeBuffer);\n // keep track of current length of writeBuffer\n // splice writeBuffer and callbackBuffer on `drain`\n this.prevBufferLen = this.writeBuffer.length;\n this.emit('flush');\n }\n};\n\n/**\n * Sends a message.\n *\n * @param {String} message.\n * @param {Function} callback function.\n * @return {Socket} for chaining.\n * @api public\n */\n\nSocket.prototype.write =\nSocket.prototype.send = function (msg, fn) {\n this.sendPacket('message', msg, fn);\n return this;\n};\n\n/**\n * Sends a packet.\n *\n * @param {String} packet type.\n * @param {String} data.\n * @param {Function} callback function.\n * @api private\n */\n\nSocket.prototype.sendPacket = function (type, data, fn) {\n if ('closing' == this.readyState || 'closed' == this.readyState) {\n return;\n }\n\n var packet = { type: type, data: data };\n this.emit('packetCreate', packet);\n this.writeBuffer.push(packet);\n this.callbackBuffer.push(fn);\n this.flush();\n};\n\n/**\n * Closes the connection.\n *\n * @api private\n */\n\nSocket.prototype.close = function () {\n if ('opening' == this.readyState || 'open' == this.readyState) {\n this.readyState = 'closing';\n\n var self = this;\n\n function close() {\n self.onClose('forced close');\n debug('socket closing - telling transport to close');\n self.transport.close();\n }\n\n function cleanupAndClose() {\n self.removeListener('upgrade', cleanupAndClose);\n self.removeListener('upgradeError', cleanupAndClose);\n close();\n }\n\n function waitForUpgrade() {\n // wait for upgrade to finish since we can't send packets while pausing a transport\n self.once('upgrade', cleanupAndClose);\n self.once('upgradeError', cleanupAndClose);\n }\n\n if (this.writeBuffer.length) {\n this.once('drain', function() {\n if (this.upgrading) {\n waitForUpgrade();\n } else {\n close();\n }\n });\n } else if (this.upgrading) {\n waitForUpgrade();\n } else {\n close();\n }\n }\n\n return this;\n};\n\n/**\n * Called upon transport error\n *\n * @api private\n */\n\nSocket.prototype.onError = function (err) {\n debug('socket error %j', err);\n Socket.priorWebsocketSuccess = false;\n this.emit('error', err);\n this.onClose('transport error', err);\n};\n\n/**\n * Called upon transport close.\n *\n * @api private\n */\n\nSocket.prototype.onClose = function (reason, desc) {\n if ('opening' == this.readyState || 'open' == this.readyState || 'closing' == this.readyState) {\n debug('socket close with reason: \"%s\"', reason);\n var self = this;\n\n // clear timers\n clearTimeout(this.pingIntervalTimer);\n clearTimeout(this.pingTimeoutTimer);\n\n // clean buffers in next tick, so developers can still\n // grab the buffers on `close` event\n setTimeout(function() {\n self.writeBuffer = [];\n self.callbackBuffer = [];\n self.prevBufferLen = 0;\n }, 0);\n\n // stop event from firing again for transport\n this.transport.removeAllListeners('close');\n\n // ensure transport won't stay open\n this.transport.close();\n\n // ignore further transport communication\n this.transport.removeAllListeners();\n\n // set ready state\n this.readyState = 'closed';\n\n // clear session id\n this.id = null;\n\n // emit close event\n this.emit('close', reason, desc);\n }\n};\n\n/**\n * Filters upgrades, returning only those matching client transports.\n *\n * @param {Array} server upgrades\n * @api private\n *\n */\n\nSocket.prototype.filterUpgrades = function (upgrades) {\n var filteredUpgrades = [];\n for (var i = 0, j = upgrades.length; i<j; i++) {\n if (~index(this.transports, upgrades[i])) filteredUpgrades.push(upgrades[i]);\n }\n return filteredUpgrades;\n};\n\n/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))\n\n/*****************\n ** WEBPACK FOOTER\n ** (webpack)-dev-server/~/socket.io-client/~/engine.io-client/lib/socket.js\n ** module id = 17\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///(webpack)-dev-server/~/socket.io-client/~/engine.io-client/lib/socket.js?");
|
||
|
||
/***/ },
|
||
/* 18 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/* WEBPACK VAR INJECTION */(function(global) {/**\n * Module dependencies\n */\n\nvar XMLHttpRequest = __webpack_require__(19);\nvar XHR = __webpack_require__(22);\nvar JSONP = __webpack_require__(40);\nvar websocket = __webpack_require__(41);\n\n/**\n * Export transports.\n */\n\nexports.polling = polling;\nexports.websocket = websocket;\n\n/**\n * Polling transport polymorphic constructor.\n * Decides on xhr vs jsonp based on feature detection.\n *\n * @api private\n */\n\nfunction polling(opts){\n var xhr;\n var xd = false;\n var xs = false;\n var jsonp = false !== opts.jsonp;\n\n if (global.location) {\n var isSSL = 'https:' == location.protocol;\n var port = location.port;\n\n // some user agents have empty `location.port`\n if (!port) {\n port = isSSL ? 443 : 80;\n }\n\n xd = opts.hostname != location.hostname || port != opts.port;\n xs = opts.secure != isSSL;\n }\n\n opts.xdomain = xd;\n opts.xscheme = xs;\n xhr = new XMLHttpRequest(opts);\n\n if ('open' in xhr && !opts.forceJSONP) {\n return new XHR(opts);\n } else {\n if (!jsonp) throw new Error('JSONP disabled');\n return new JSONP(opts);\n }\n}\n\n/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))\n\n/*****************\n ** WEBPACK FOOTER\n ** (webpack)-dev-server/~/socket.io-client/~/engine.io-client/lib/transports/index.js\n ** module id = 18\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///(webpack)-dev-server/~/socket.io-client/~/engine.io-client/lib/transports/index.js?");
|
||
|
||
/***/ },
|
||
/* 19 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("// browser shim for xmlhttprequest module\nvar hasCORS = __webpack_require__(20);\n\nmodule.exports = function(opts) {\n var xdomain = opts.xdomain;\n\n // scheme must be same when usign XDomainRequest\n // http://blogs.msdn.com/b/ieinternals/archive/2010/05/13/xdomainrequest-restrictions-limitations-and-workarounds.aspx\n var xscheme = opts.xscheme;\n\n // XDomainRequest has a flow of not sending cookie, therefore it should be disabled as a default.\n // https://github.com/Automattic/engine.io-client/pull/217\n var enablesXDR = opts.enablesXDR;\n\n // XMLHttpRequest can be disabled on IE\n try {\n if ('undefined' != typeof XMLHttpRequest && (!xdomain || hasCORS)) {\n return new XMLHttpRequest();\n }\n } catch (e) { }\n\n // Use XDomainRequest for IE8 if enablesXDR is true\n // because loading bar keeps flashing when using jsonp-polling\n // https://github.com/yujiosaka/socke.io-ie8-loading-example\n try {\n if ('undefined' != typeof XDomainRequest && !xscheme && enablesXDR) {\n return new XDomainRequest();\n }\n } catch (e) { }\n\n if (!xdomain) {\n try {\n return new ActiveXObject('Microsoft.XMLHTTP');\n } catch(e) { }\n }\n}\n\n\n/*****************\n ** WEBPACK FOOTER\n ** (webpack)-dev-server/~/socket.io-client/~/engine.io-client/lib/xmlhttprequest.js\n ** module id = 19\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///(webpack)-dev-server/~/socket.io-client/~/engine.io-client/lib/xmlhttprequest.js?");
|
||
|
||
/***/ },
|
||
/* 20 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("\n/**\n * Module dependencies.\n */\n\nvar global = __webpack_require__(21);\n\n/**\n * Module exports.\n *\n * Logic borrowed from Modernizr:\n *\n * - https://github.com/Modernizr/Modernizr/blob/master/feature-detects/cors.js\n */\n\ntry {\n module.exports = 'XMLHttpRequest' in global &&\n 'withCredentials' in new global.XMLHttpRequest();\n} catch (err) {\n // if XMLHttp support is disabled in IE then it will throw\n // when trying to create\n module.exports = false;\n}\n\n\n/*****************\n ** WEBPACK FOOTER\n ** (webpack)-dev-server/~/socket.io-client/~/engine.io-client/~/has-cors/index.js\n ** module id = 20\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///(webpack)-dev-server/~/socket.io-client/~/engine.io-client/~/has-cors/index.js?");
|
||
|
||
/***/ },
|
||
/* 21 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("\n/**\n * Returns `this`. Execute this without a \"context\" (i.e. without it being\n * attached to an object of the left-hand side), and `this` points to the\n * \"global\" scope of the current JS execution.\n */\n\nmodule.exports = (function () { return this; })();\n\n\n/*****************\n ** WEBPACK FOOTER\n ** (webpack)-dev-server/~/socket.io-client/~/engine.io-client/~/has-cors/~/global/index.js\n ** module id = 21\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///(webpack)-dev-server/~/socket.io-client/~/engine.io-client/~/has-cors/~/global/index.js?");
|
||
|
||
/***/ },
|
||
/* 22 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/* WEBPACK VAR INJECTION */(function(global) {/**\n * Module requirements.\n */\n\nvar XMLHttpRequest = __webpack_require__(19);\nvar Polling = __webpack_require__(23);\nvar Emitter = __webpack_require__(8);\nvar inherit = __webpack_require__(24);\nvar debug = __webpack_require__(37)('engine.io-client:polling-xhr');\n\n/**\n * Module exports.\n */\n\nmodule.exports = XHR;\nmodule.exports.Request = Request;\n\n/**\n * Empty function\n */\n\nfunction empty(){}\n\n/**\n * XHR Polling constructor.\n *\n * @param {Object} opts\n * @api public\n */\n\nfunction XHR(opts){\n Polling.call(this, opts);\n\n if (global.location) {\n var isSSL = 'https:' == location.protocol;\n var port = location.port;\n\n // some user agents have empty `location.port`\n if (!port) {\n port = isSSL ? 443 : 80;\n }\n\n this.xd = opts.hostname != global.location.hostname ||\n port != opts.port;\n this.xs = opts.secure != isSSL;\n }\n}\n\n/**\n * Inherits from Polling.\n */\n\ninherit(XHR, Polling);\n\n/**\n * XHR supports binary\n */\n\nXHR.prototype.supportsBinary = true;\n\n/**\n * Creates a request.\n *\n * @param {String} method\n * @api private\n */\n\nXHR.prototype.request = function(opts){\n opts = opts || {};\n opts.uri = this.uri();\n opts.xd = this.xd;\n opts.xs = this.xs;\n opts.agent = this.agent || false;\n opts.supportsBinary = this.supportsBinary;\n opts.enablesXDR = this.enablesXDR;\n\n // SSL options for Node.js client\n opts.pfx = this.pfx;\n opts.key = this.key;\n opts.passphrase = this.passphrase;\n opts.cert = this.cert;\n opts.ca = this.ca;\n opts.ciphers = this.ciphers;\n opts.rejectUnauthorized = this.rejectUnauthorized;\n\n return new Request(opts);\n};\n\n/**\n * Sends data.\n *\n * @param {String} data to send.\n * @param {Function} called upon flush.\n * @api private\n */\n\nXHR.prototype.doWrite = function(data, fn){\n var isBinary = typeof data !== 'string' && data !== undefined;\n var req = this.request({ method: 'POST', data: data, isBinary: isBinary });\n var self = this;\n req.on('success', fn);\n req.on('error', function(err){\n self.onError('xhr post error', err);\n });\n this.sendXhr = req;\n};\n\n/**\n * Starts a poll cycle.\n *\n * @api private\n */\n\nXHR.prototype.doPoll = function(){\n debug('xhr poll');\n var req = this.request();\n var self = this;\n req.on('data', function(data){\n self.onData(data);\n });\n req.on('error', function(err){\n self.onError('xhr poll error', err);\n });\n this.pollXhr = req;\n};\n\n/**\n * Request constructor\n *\n * @param {Object} options\n * @api public\n */\n\nfunction Request(opts){\n this.method = opts.method || 'GET';\n this.uri = opts.uri;\n this.xd = !!opts.xd;\n this.xs = !!opts.xs;\n this.async = false !== opts.async;\n this.data = undefined != opts.data ? opts.data : null;\n this.agent = opts.agent;\n this.isBinary = opts.isBinary;\n this.supportsBinary = opts.supportsBinary;\n this.enablesXDR = opts.enablesXDR;\n\n // SSL options for Node.js client\n this.pfx = opts.pfx;\n this.key = opts.key;\n this.passphrase = opts.passphrase;\n this.cert = opts.cert;\n this.ca = opts.ca;\n this.ciphers = opts.ciphers;\n this.rejectUnauthorized = opts.rejectUnauthorized;\n\n this.create();\n}\n\n/**\n * Mix in `Emitter`.\n */\n\nEmitter(Request.prototype);\n\n/**\n * Creates the XHR object and sends the request.\n *\n * @api private\n */\n\nRequest.prototype.create = function(){\n var opts = { agent: this.agent, xdomain: this.xd, xscheme: this.xs, enablesXDR: this.enablesXDR };\n\n // SSL options for Node.js client\n opts.pfx = this.pfx;\n opts.key = this.key;\n opts.passphrase = this.passphrase;\n opts.cert = this.cert;\n opts.ca = this.ca;\n opts.ciphers = this.ciphers;\n opts.rejectUnauthorized = this.rejectUnauthorized;\n\n var xhr = this.xhr = new XMLHttpRequest(opts);\n var self = this;\n\n try {\n debug('xhr open %s: %s', this.method, this.uri);\n xhr.open(this.method, this.uri, this.async);\n if (this.supportsBinary) {\n // This has to be done after open because Firefox is stupid\n // http://stackoverflow.com/questions/13216903/get-binary-data-with-xmlhttprequest-in-a-firefox-extension\n xhr.responseType = 'arraybuffer';\n }\n\n if ('POST' == this.method) {\n try {\n if (this.isBinary) {\n xhr.setRequestHeader('Content-type', 'application/octet-stream');\n } else {\n xhr.setRequestHeader('Content-type', 'text/plain;charset=UTF-8');\n }\n } catch (e) {}\n }\n\n // ie6 check\n if ('withCredentials' in xhr) {\n xhr.withCredentials = true;\n }\n\n if (this.hasXDR()) {\n xhr.onload = function(){\n self.onLoad();\n };\n xhr.onerror = function(){\n self.onError(xhr.responseText);\n };\n } else {\n xhr.onreadystatechange = function(){\n if (4 != xhr.readyState) return;\n if (200 == xhr.status || 1223 == xhr.status) {\n self.onLoad();\n } else {\n // make sure the `error` event handler that's user-set\n // does not throw in the same tick and gets caught here\n setTimeout(function(){\n self.onError(xhr.status);\n }, 0);\n }\n };\n }\n\n debug('xhr data %s', this.data);\n xhr.send(this.data);\n } catch (e) {\n // Need to defer since .create() is called directly fhrom the constructor\n // and thus the 'error' event can only be only bound *after* this exception\n // occurs. Therefore, also, we cannot throw here at all.\n setTimeout(function() {\n self.onError(e);\n }, 0);\n return;\n }\n\n if (global.document) {\n this.index = Request.requestsCount++;\n Request.requests[this.index] = this;\n }\n};\n\n/**\n * Called upon successful response.\n *\n * @api private\n */\n\nRequest.prototype.onSuccess = function(){\n this.emit('success');\n this.cleanup();\n};\n\n/**\n * Called if we have data.\n *\n * @api private\n */\n\nRequest.prototype.onData = function(data){\n this.emit('data', data);\n this.onSuccess();\n};\n\n/**\n * Called upon error.\n *\n * @api private\n */\n\nRequest.prototype.onError = function(err){\n this.emit('error', err);\n this.cleanup(true);\n};\n\n/**\n * Cleans up house.\n *\n * @api private\n */\n\nRequest.prototype.cleanup = function(fromError){\n if ('undefined' == typeof this.xhr || null === this.xhr) {\n return;\n }\n // xmlhttprequest\n if (this.hasXDR()) {\n this.xhr.onload = this.xhr.onerror = empty;\n } else {\n this.xhr.onreadystatechange = empty;\n }\n\n if (fromError) {\n try {\n this.xhr.abort();\n } catch(e) {}\n }\n\n if (global.document) {\n delete Request.requests[this.index];\n }\n\n this.xhr = null;\n};\n\n/**\n * Called upon load.\n *\n * @api private\n */\n\nRequest.prototype.onLoad = function(){\n var data;\n try {\n var contentType;\n try {\n contentType = this.xhr.getResponseHeader('Content-Type').split(';')[0];\n } catch (e) {}\n if (contentType === 'application/octet-stream') {\n data = this.xhr.response;\n } else {\n if (!this.supportsBinary) {\n data = this.xhr.responseText;\n } else {\n data = 'ok';\n }\n }\n } catch (e) {\n this.onError(e);\n }\n if (null != data) {\n this.onData(data);\n }\n};\n\n/**\n * Check if it has XDomainRequest.\n *\n * @api private\n */\n\nRequest.prototype.hasXDR = function(){\n return 'undefined' !== typeof global.XDomainRequest && !this.xs && this.enablesXDR;\n};\n\n/**\n * Aborts the request.\n *\n * @api public\n */\n\nRequest.prototype.abort = function(){\n this.cleanup();\n};\n\n/**\n * Aborts pending requests when unloading the window. This is needed to prevent\n * memory leaks (e.g. when using IE) and to ensure that no spurious error is\n * emitted.\n */\n\nif (global.document) {\n Request.requestsCount = 0;\n Request.requests = {};\n if (global.attachEvent) {\n global.attachEvent('onunload', unloadHandler);\n } else if (global.addEventListener) {\n global.addEventListener('beforeunload', unloadHandler, false);\n }\n}\n\nfunction unloadHandler() {\n for (var i in Request.requests) {\n if (Request.requests.hasOwnProperty(i)) {\n Request.requests[i].abort();\n }\n }\n}\n\n/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))\n\n/*****************\n ** WEBPACK FOOTER\n ** (webpack)-dev-server/~/socket.io-client/~/engine.io-client/lib/transports/polling-xhr.js\n ** module id = 22\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///(webpack)-dev-server/~/socket.io-client/~/engine.io-client/lib/transports/polling-xhr.js?");
|
||
|
||
/***/ },
|
||
/* 23 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\n * Module dependencies.\n */\n\nvar Transport = __webpack_require__(25);\nvar parseqs = __webpack_require__(36);\nvar parser = __webpack_require__(26);\nvar inherit = __webpack_require__(24);\nvar debug = __webpack_require__(37)('engine.io-client:polling');\n\n/**\n * Module exports.\n */\n\nmodule.exports = Polling;\n\n/**\n * Is XHR2 supported?\n */\n\nvar hasXHR2 = (function() {\n var XMLHttpRequest = __webpack_require__(19);\n var xhr = new XMLHttpRequest({ xdomain: false });\n return null != xhr.responseType;\n})();\n\n/**\n * Polling interface.\n *\n * @param {Object} opts\n * @api private\n */\n\nfunction Polling(opts){\n var forceBase64 = (opts && opts.forceBase64);\n if (!hasXHR2 || forceBase64) {\n this.supportsBinary = false;\n }\n Transport.call(this, opts);\n}\n\n/**\n * Inherits from Transport.\n */\n\ninherit(Polling, Transport);\n\n/**\n * Transport name.\n */\n\nPolling.prototype.name = 'polling';\n\n/**\n * Opens the socket (triggers polling). We write a PING message to determine\n * when the transport is open.\n *\n * @api private\n */\n\nPolling.prototype.doOpen = function(){\n this.poll();\n};\n\n/**\n * Pauses polling.\n *\n * @param {Function} callback upon buffers are flushed and transport is paused\n * @api private\n */\n\nPolling.prototype.pause = function(onPause){\n var pending = 0;\n var self = this;\n\n this.readyState = 'pausing';\n\n function pause(){\n debug('paused');\n self.readyState = 'paused';\n onPause();\n }\n\n if (this.polling || !this.writable) {\n var total = 0;\n\n if (this.polling) {\n debug('we are currently polling - waiting to pause');\n total++;\n this.once('pollComplete', function(){\n debug('pre-pause polling complete');\n --total || pause();\n });\n }\n\n if (!this.writable) {\n debug('we are currently writing - waiting to pause');\n total++;\n this.once('drain', function(){\n debug('pre-pause writing complete');\n --total || pause();\n });\n }\n } else {\n pause();\n }\n};\n\n/**\n * Starts polling cycle.\n *\n * @api public\n */\n\nPolling.prototype.poll = function(){\n debug('polling');\n this.polling = true;\n this.doPoll();\n this.emit('poll');\n};\n\n/**\n * Overloads onData to detect payloads.\n *\n * @api private\n */\n\nPolling.prototype.onData = function(data){\n var self = this;\n debug('polling got data %s', data);\n var callback = function(packet, index, total) {\n // if its the first message we consider the transport open\n if ('opening' == self.readyState) {\n self.onOpen();\n }\n\n // if its a close packet, we close the ongoing requests\n if ('close' == packet.type) {\n self.onClose();\n return false;\n }\n\n // otherwise bypass onData and handle the message\n self.onPacket(packet);\n };\n\n // decode payload\n parser.decodePayload(data, this.socket.binaryType, callback);\n\n // if an event did not trigger closing\n if ('closed' != this.readyState) {\n // if we got data we're not polling\n this.polling = false;\n this.emit('pollComplete');\n\n if ('open' == this.readyState) {\n this.poll();\n } else {\n debug('ignoring poll - transport state \"%s\"', this.readyState);\n }\n }\n};\n\n/**\n * For polling, send a close packet.\n *\n * @api private\n */\n\nPolling.prototype.doClose = function(){\n var self = this;\n\n function close(){\n debug('writing close packet');\n self.write([{ type: 'close' }]);\n }\n\n if ('open' == this.readyState) {\n debug('transport open - closing');\n close();\n } else {\n // in case we're trying to close while\n // handshaking is in progress (GH-164)\n debug('transport not open - deferring close');\n this.once('open', close);\n }\n};\n\n/**\n * Writes a packets payload.\n *\n * @param {Array} data packets\n * @param {Function} drain callback\n * @api private\n */\n\nPolling.prototype.write = function(packets){\n var self = this;\n this.writable = false;\n var callbackfn = function() {\n self.writable = true;\n self.emit('drain');\n };\n\n var self = this;\n parser.encodePayload(packets, this.supportsBinary, function(data) {\n self.doWrite(data, callbackfn);\n });\n};\n\n/**\n * Generates uri for connection.\n *\n * @api private\n */\n\nPolling.prototype.uri = function(){\n var query = this.query || {};\n var schema = this.secure ? 'https' : 'http';\n var port = '';\n\n // cache busting is forced\n if (false !== this.timestampRequests) {\n query[this.timestampParam] = +new Date + '-' + Transport.timestamps++;\n }\n\n if (!this.supportsBinary && !query.sid) {\n query.b64 = 1;\n }\n\n query = parseqs.encode(query);\n\n // avoid port if default for schema\n if (this.port && (('https' == schema && this.port != 443) ||\n ('http' == schema && this.port != 80))) {\n port = ':' + this.port;\n }\n\n // prepend ? to query\n if (query.length) {\n query = '?' + query;\n }\n\n return schema + '://' + this.hostname + port + this.path + query;\n};\n\n\n/*****************\n ** WEBPACK FOOTER\n ** (webpack)-dev-server/~/socket.io-client/~/engine.io-client/lib/transports/polling.js\n ** module id = 23\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///(webpack)-dev-server/~/socket.io-client/~/engine.io-client/lib/transports/polling.js?");
|
||
|
||
/***/ },
|
||
/* 24 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("\nmodule.exports = function(a, b){\n var fn = function(){};\n fn.prototype = b.prototype;\n a.prototype = new fn;\n a.prototype.constructor = a;\n};\n\n/*****************\n ** WEBPACK FOOTER\n ** (webpack)-dev-server/~/socket.io-client/~/engine.io-client/~/component-inherit/index.js\n ** module id = 24\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///(webpack)-dev-server/~/socket.io-client/~/engine.io-client/~/component-inherit/index.js?");
|
||
|
||
/***/ },
|
||
/* 25 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\n * Module dependencies.\n */\n\nvar parser = __webpack_require__(26);\nvar Emitter = __webpack_require__(8);\n\n/**\n * Module exports.\n */\n\nmodule.exports = Transport;\n\n/**\n * Transport abstract constructor.\n *\n * @param {Object} options.\n * @api private\n */\n\nfunction Transport (opts) {\n this.path = opts.path;\n this.hostname = opts.hostname;\n this.port = opts.port;\n this.secure = opts.secure;\n this.query = opts.query;\n this.timestampParam = opts.timestampParam;\n this.timestampRequests = opts.timestampRequests;\n this.readyState = '';\n this.agent = opts.agent || false;\n this.socket = opts.socket;\n this.enablesXDR = opts.enablesXDR;\n\n // SSL options for Node.js client\n this.pfx = opts.pfx;\n this.key = opts.key;\n this.passphrase = opts.passphrase;\n this.cert = opts.cert;\n this.ca = opts.ca;\n this.ciphers = opts.ciphers;\n this.rejectUnauthorized = opts.rejectUnauthorized;\n}\n\n/**\n * Mix in `Emitter`.\n */\n\nEmitter(Transport.prototype);\n\n/**\n * A counter used to prevent collisions in the timestamps used\n * for cache busting.\n */\n\nTransport.timestamps = 0;\n\n/**\n * Emits an error.\n *\n * @param {String} str\n * @return {Transport} for chaining\n * @api public\n */\n\nTransport.prototype.onError = function (msg, desc) {\n var err = new Error(msg);\n err.type = 'TransportError';\n err.description = desc;\n this.emit('error', err);\n return this;\n};\n\n/**\n * Opens the transport.\n *\n * @api public\n */\n\nTransport.prototype.open = function () {\n if ('closed' == this.readyState || '' == this.readyState) {\n this.readyState = 'opening';\n this.doOpen();\n }\n\n return this;\n};\n\n/**\n * Closes the transport.\n *\n * @api private\n */\n\nTransport.prototype.close = function () {\n if ('opening' == this.readyState || 'open' == this.readyState) {\n this.doClose();\n this.onClose();\n }\n\n return this;\n};\n\n/**\n * Sends multiple packets.\n *\n * @param {Array} packets\n * @api private\n */\n\nTransport.prototype.send = function(packets){\n if ('open' == this.readyState) {\n this.write(packets);\n } else {\n throw new Error('Transport not open');\n }\n};\n\n/**\n * Called upon open\n *\n * @api private\n */\n\nTransport.prototype.onOpen = function () {\n this.readyState = 'open';\n this.writable = true;\n this.emit('open');\n};\n\n/**\n * Called with data.\n *\n * @param {String} data\n * @api private\n */\n\nTransport.prototype.onData = function(data){\n var packet = parser.decodePacket(data, this.socket.binaryType);\n this.onPacket(packet);\n};\n\n/**\n * Called with a decoded packet.\n */\n\nTransport.prototype.onPacket = function (packet) {\n this.emit('packet', packet);\n};\n\n/**\n * Called upon close.\n *\n * @api private\n */\n\nTransport.prototype.onClose = function () {\n this.readyState = 'closed';\n this.emit('close');\n};\n\n\n/*****************\n ** WEBPACK FOOTER\n ** (webpack)-dev-server/~/socket.io-client/~/engine.io-client/lib/transport.js\n ** module id = 25\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///(webpack)-dev-server/~/socket.io-client/~/engine.io-client/lib/transport.js?");
|
||
|
||
/***/ },
|
||
/* 26 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/* WEBPACK VAR INJECTION */(function(global) {/**\n * Module dependencies.\n */\n\nvar keys = __webpack_require__(27);\nvar hasBinary = __webpack_require__(28);\nvar sliceBuffer = __webpack_require__(30);\nvar base64encoder = __webpack_require__(31);\nvar after = __webpack_require__(32);\nvar utf8 = __webpack_require__(33);\n\n/**\n * Check if we are running an android browser. That requires us to use\n * ArrayBuffer with polling transports...\n *\n * http://ghinda.net/jpeg-blob-ajax-android/\n */\n\nvar isAndroid = navigator.userAgent.match(/Android/i);\n\n/**\n * Check if we are running in PhantomJS.\n * Uploading a Blob with PhantomJS does not work correctly, as reported here:\n * https://github.com/ariya/phantomjs/issues/11395\n * @type boolean\n */\nvar isPhantomJS = /PhantomJS/i.test(navigator.userAgent);\n\n/**\n * When true, avoids using Blobs to encode payloads.\n * @type boolean\n */\nvar dontSendBlobs = isAndroid || isPhantomJS;\n\n/**\n * Current protocol version.\n */\n\nexports.protocol = 3;\n\n/**\n * Packet types.\n */\n\nvar packets = exports.packets = {\n open: 0 // non-ws\n , close: 1 // non-ws\n , ping: 2\n , pong: 3\n , message: 4\n , upgrade: 5\n , noop: 6\n};\n\nvar packetslist = keys(packets);\n\n/**\n * Premade error packet.\n */\n\nvar err = { type: 'error', data: 'parser error' };\n\n/**\n * Create a blob api even for blob builder when vendor prefixes exist\n */\n\nvar Blob = __webpack_require__(35);\n\n/**\n * Encodes a packet.\n *\n * <packet type id> [ <data> ]\n *\n * Example:\n *\n * 5hello world\n * 3\n * 4\n *\n * Binary is encoded in an identical principle\n *\n * @api private\n */\n\nexports.encodePacket = function (packet, supportsBinary, utf8encode, callback) {\n if ('function' == typeof supportsBinary) {\n callback = supportsBinary;\n supportsBinary = false;\n }\n\n if ('function' == typeof utf8encode) {\n callback = utf8encode;\n utf8encode = null;\n }\n\n var data = (packet.data === undefined)\n ? undefined\n : packet.data.buffer || packet.data;\n\n if (global.ArrayBuffer && data instanceof ArrayBuffer) {\n return encodeArrayBuffer(packet, supportsBinary, callback);\n } else if (Blob && data instanceof global.Blob) {\n return encodeBlob(packet, supportsBinary, callback);\n }\n\n // might be an object with { base64: true, data: dataAsBase64String }\n if (data && data.base64) {\n return encodeBase64Object(packet, callback);\n }\n\n // Sending data as a utf-8 string\n var encoded = packets[packet.type];\n\n // data fragment is optional\n if (undefined !== packet.data) {\n encoded += utf8encode ? utf8.encode(String(packet.data)) : String(packet.data);\n }\n\n return callback('' + encoded);\n\n};\n\nfunction encodeBase64Object(packet, callback) {\n // packet data is an object { base64: true, data: dataAsBase64String }\n var message = 'b' + exports.packets[packet.type] + packet.data.data;\n return callback(message);\n}\n\n/**\n * Encode packet helpers for binary types\n */\n\nfunction encodeArrayBuffer(packet, supportsBinary, callback) {\n if (!supportsBinary) {\n return exports.encodeBase64Packet(packet, callback);\n }\n\n var data = packet.data;\n var contentArray = new Uint8Array(data);\n var resultBuffer = new Uint8Array(1 + data.byteLength);\n\n resultBuffer[0] = packets[packet.type];\n for (var i = 0; i < contentArray.length; i++) {\n resultBuffer[i+1] = contentArray[i];\n }\n\n return callback(resultBuffer.buffer);\n}\n\nfunction encodeBlobAsArrayBuffer(packet, supportsBinary, callback) {\n if (!supportsBinary) {\n return exports.encodeBase64Packet(packet, callback);\n }\n\n var fr = new FileReader();\n fr.onload = function() {\n packet.data = fr.result;\n exports.encodePacket(packet, supportsBinary, true, callback);\n };\n return fr.readAsArrayBuffer(packet.data);\n}\n\nfunction encodeBlob(packet, supportsBinary, callback) {\n if (!supportsBinary) {\n return exports.encodeBase64Packet(packet, callback);\n }\n\n if (dontSendBlobs) {\n return encodeBlobAsArrayBuffer(packet, supportsBinary, callback);\n }\n\n var length = new Uint8Array(1);\n length[0] = packets[packet.type];\n var blob = new Blob([length.buffer, packet.data]);\n\n return callback(blob);\n}\n\n/**\n * Encodes a packet with binary data in a base64 string\n *\n * @param {Object} packet, has `type` and `data`\n * @return {String} base64 encoded message\n */\n\nexports.encodeBase64Packet = function(packet, callback) {\n var message = 'b' + exports.packets[packet.type];\n if (Blob && packet.data instanceof Blob) {\n var fr = new FileReader();\n fr.onload = function() {\n var b64 = fr.result.split(',')[1];\n callback(message + b64);\n };\n return fr.readAsDataURL(packet.data);\n }\n\n var b64data;\n try {\n b64data = String.fromCharCode.apply(null, new Uint8Array(packet.data));\n } catch (e) {\n // iPhone Safari doesn't let you apply with typed arrays\n var typed = new Uint8Array(packet.data);\n var basic = new Array(typed.length);\n for (var i = 0; i < typed.length; i++) {\n basic[i] = typed[i];\n }\n b64data = String.fromCharCode.apply(null, basic);\n }\n message += global.btoa(b64data);\n return callback(message);\n};\n\n/**\n * Decodes a packet. Changes format to Blob if requested.\n *\n * @return {Object} with `type` and `data` (if any)\n * @api private\n */\n\nexports.decodePacket = function (data, binaryType, utf8decode) {\n // String data\n if (typeof data == 'string' || data === undefined) {\n if (data.charAt(0) == 'b') {\n return exports.decodeBase64Packet(data.substr(1), binaryType);\n }\n\n if (utf8decode) {\n try {\n data = utf8.decode(data);\n } catch (e) {\n return err;\n }\n }\n var type = data.charAt(0);\n\n if (Number(type) != type || !packetslist[type]) {\n return err;\n }\n\n if (data.length > 1) {\n return { type: packetslist[type], data: data.substring(1) };\n } else {\n return { type: packetslist[type] };\n }\n }\n\n var asArray = new Uint8Array(data);\n var type = asArray[0];\n var rest = sliceBuffer(data, 1);\n if (Blob && binaryType === 'blob') {\n rest = new Blob([rest]);\n }\n return { type: packetslist[type], data: rest };\n};\n\n/**\n * Decodes a packet encoded in a base64 string\n *\n * @param {String} base64 encoded message\n * @return {Object} with `type` and `data` (if any)\n */\n\nexports.decodeBase64Packet = function(msg, binaryType) {\n var type = packetslist[msg.charAt(0)];\n if (!global.ArrayBuffer) {\n return { type: type, data: { base64: true, data: msg.substr(1) } };\n }\n\n var data = base64encoder.decode(msg.substr(1));\n\n if (binaryType === 'blob' && Blob) {\n data = new Blob([data]);\n }\n\n return { type: type, data: data };\n};\n\n/**\n * Encodes multiple messages (payload).\n *\n * <length>:data\n *\n * Example:\n *\n * 11:hello world2:hi\n *\n * If any contents are binary, they will be encoded as base64 strings. Base64\n * encoded strings are marked with a b before the length specifier\n *\n * @param {Array} packets\n * @api private\n */\n\nexports.encodePayload = function (packets, supportsBinary, callback) {\n if (typeof supportsBinary == 'function') {\n callback = supportsBinary;\n supportsBinary = null;\n }\n\n var isBinary = hasBinary(packets);\n\n if (supportsBinary && isBinary) {\n if (Blob && !dontSendBlobs) {\n return exports.encodePayloadAsBlob(packets, callback);\n }\n\n return exports.encodePayloadAsArrayBuffer(packets, callback);\n }\n\n if (!packets.length) {\n return callback('0:');\n }\n\n function setLengthHeader(message) {\n return message.length + ':' + message;\n }\n\n function encodeOne(packet, doneCallback) {\n exports.encodePacket(packet, !isBinary ? false : supportsBinary, true, function(message) {\n doneCallback(null, setLengthHeader(message));\n });\n }\n\n map(packets, encodeOne, function(err, results) {\n return callback(results.join(''));\n });\n};\n\n/**\n * Async array map using after\n */\n\nfunction map(ary, each, done) {\n var result = new Array(ary.length);\n var next = after(ary.length, done);\n\n var eachWithIndex = function(i, el, cb) {\n each(el, function(error, msg) {\n result[i] = msg;\n cb(error, result);\n });\n };\n\n for (var i = 0; i < ary.length; i++) {\n eachWithIndex(i, ary[i], next);\n }\n}\n\n/*\n * Decodes data when a payload is maybe expected. Possible binary contents are\n * decoded from their base64 representation\n *\n * @param {String} data, callback method\n * @api public\n */\n\nexports.decodePayload = function (data, binaryType, callback) {\n if (typeof data != 'string') {\n return exports.decodePayloadAsBinary(data, binaryType, callback);\n }\n\n if (typeof binaryType === 'function') {\n callback = binaryType;\n binaryType = null;\n }\n\n var packet;\n if (data == '') {\n // parser error - ignoring payload\n return callback(err, 0, 1);\n }\n\n var length = ''\n , n, msg;\n\n for (var i = 0, l = data.length; i < l; i++) {\n var chr = data.charAt(i);\n\n if (':' != chr) {\n length += chr;\n } else {\n if ('' == length || (length != (n = Number(length)))) {\n // parser error - ignoring payload\n return callback(err, 0, 1);\n }\n\n msg = data.substr(i + 1, n);\n\n if (length != msg.length) {\n // parser error - ignoring payload\n return callback(err, 0, 1);\n }\n\n if (msg.length) {\n packet = exports.decodePacket(msg, binaryType, true);\n\n if (err.type == packet.type && err.data == packet.data) {\n // parser error in individual packet - ignoring payload\n return callback(err, 0, 1);\n }\n\n var ret = callback(packet, i + n, l);\n if (false === ret) return;\n }\n\n // advance cursor\n i += n;\n length = '';\n }\n }\n\n if (length != '') {\n // parser error - ignoring payload\n return callback(err, 0, 1);\n }\n\n};\n\n/**\n * Encodes multiple messages (payload) as binary.\n *\n * <1 = binary, 0 = string><number from 0-9><number from 0-9>[...]<number\n * 255><data>\n *\n * Example:\n * 1 3 255 1 2 3, if the binary contents are interpreted as 8 bit integers\n *\n * @param {Array} packets\n * @return {ArrayBuffer} encoded payload\n * @api private\n */\n\nexports.encodePayloadAsArrayBuffer = function(packets, callback) {\n if (!packets.length) {\n return callback(new ArrayBuffer(0));\n }\n\n function encodeOne(packet, doneCallback) {\n exports.encodePacket(packet, true, true, function(data) {\n return doneCallback(null, data);\n });\n }\n\n map(packets, encodeOne, function(err, encodedPackets) {\n var totalLength = encodedPackets.reduce(function(acc, p) {\n var len;\n if (typeof p === 'string'){\n len = p.length;\n } else {\n len = p.byteLength;\n }\n return acc + len.toString().length + len + 2; // string/binary identifier + separator = 2\n }, 0);\n\n var resultArray = new Uint8Array(totalLength);\n\n var bufferIndex = 0;\n encodedPackets.forEach(function(p) {\n var isString = typeof p === 'string';\n var ab = p;\n if (isString) {\n var view = new Uint8Array(p.length);\n for (var i = 0; i < p.length; i++) {\n view[i] = p.charCodeAt(i);\n }\n ab = view.buffer;\n }\n\n if (isString) { // not true binary\n resultArray[bufferIndex++] = 0;\n } else { // true binary\n resultArray[bufferIndex++] = 1;\n }\n\n var lenStr = ab.byteLength.toString();\n for (var i = 0; i < lenStr.length; i++) {\n resultArray[bufferIndex++] = parseInt(lenStr[i]);\n }\n resultArray[bufferIndex++] = 255;\n\n var view = new Uint8Array(ab);\n for (var i = 0; i < view.length; i++) {\n resultArray[bufferIndex++] = view[i];\n }\n });\n\n return callback(resultArray.buffer);\n });\n};\n\n/**\n * Encode as Blob\n */\n\nexports.encodePayloadAsBlob = function(packets, callback) {\n function encodeOne(packet, doneCallback) {\n exports.encodePacket(packet, true, true, function(encoded) {\n var binaryIdentifier = new Uint8Array(1);\n binaryIdentifier[0] = 1;\n if (typeof encoded === 'string') {\n var view = new Uint8Array(encoded.length);\n for (var i = 0; i < encoded.length; i++) {\n view[i] = encoded.charCodeAt(i);\n }\n encoded = view.buffer;\n binaryIdentifier[0] = 0;\n }\n\n var len = (encoded instanceof ArrayBuffer)\n ? encoded.byteLength\n : encoded.size;\n\n var lenStr = len.toString();\n var lengthAry = new Uint8Array(lenStr.length + 1);\n for (var i = 0; i < lenStr.length; i++) {\n lengthAry[i] = parseInt(lenStr[i]);\n }\n lengthAry[lenStr.length] = 255;\n\n if (Blob) {\n var blob = new Blob([binaryIdentifier.buffer, lengthAry.buffer, encoded]);\n doneCallback(null, blob);\n }\n });\n }\n\n map(packets, encodeOne, function(err, results) {\n return callback(new Blob(results));\n });\n};\n\n/*\n * Decodes data when a payload is maybe expected. Strings are decoded by\n * interpreting each byte as a key code for entries marked to start with 0. See\n * description of encodePayloadAsBinary\n *\n * @param {ArrayBuffer} data, callback method\n * @api public\n */\n\nexports.decodePayloadAsBinary = function (data, binaryType, callback) {\n if (typeof binaryType === 'function') {\n callback = binaryType;\n binaryType = null;\n }\n\n var bufferTail = data;\n var buffers = [];\n\n var numberTooLong = false;\n while (bufferTail.byteLength > 0) {\n var tailArray = new Uint8Array(bufferTail);\n var isString = tailArray[0] === 0;\n var msgLength = '';\n\n for (var i = 1; ; i++) {\n if (tailArray[i] == 255) break;\n\n if (msgLength.length > 310) {\n numberTooLong = true;\n break;\n }\n\n msgLength += tailArray[i];\n }\n\n if(numberTooLong) return callback(err, 0, 1);\n\n bufferTail = sliceBuffer(bufferTail, 2 + msgLength.length);\n msgLength = parseInt(msgLength);\n\n var msg = sliceBuffer(bufferTail, 0, msgLength);\n if (isString) {\n try {\n msg = String.fromCharCode.apply(null, new Uint8Array(msg));\n } catch (e) {\n // iPhone Safari doesn't let you apply to typed arrays\n var typed = new Uint8Array(msg);\n msg = '';\n for (var i = 0; i < typed.length; i++) {\n msg += String.fromCharCode(typed[i]);\n }\n }\n }\n\n buffers.push(msg);\n bufferTail = sliceBuffer(bufferTail, msgLength);\n }\n\n var total = buffers.length;\n buffers.forEach(function(buffer, i) {\n callback(exports.decodePacket(buffer, binaryType, true), i, total);\n });\n};\n\n/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))\n\n/*****************\n ** WEBPACK FOOTER\n ** (webpack)-dev-server/~/socket.io-client/~/engine.io-client/~/engine.io-parser/lib/browser.js\n ** module id = 26\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///(webpack)-dev-server/~/socket.io-client/~/engine.io-client/~/engine.io-parser/lib/browser.js?");
|
||
|
||
/***/ },
|
||
/* 27 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("\n/**\n * Gets the keys for an object.\n *\n * @return {Array} keys\n * @api private\n */\n\nmodule.exports = Object.keys || function keys (obj){\n var arr = [];\n var has = Object.prototype.hasOwnProperty;\n\n for (var i in obj) {\n if (has.call(obj, i)) {\n arr.push(i);\n }\n }\n return arr;\n};\n\n\n/*****************\n ** WEBPACK FOOTER\n ** (webpack)-dev-server/~/socket.io-client/~/engine.io-client/~/engine.io-parser/lib/keys.js\n ** module id = 27\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///(webpack)-dev-server/~/socket.io-client/~/engine.io-client/~/engine.io-parser/lib/keys.js?");
|
||
|
||
/***/ },
|
||
/* 28 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/* WEBPACK VAR INJECTION */(function(global) {\n/*\n * Module requirements.\n */\n\nvar isArray = __webpack_require__(29);\n\n/**\n * Module exports.\n */\n\nmodule.exports = hasBinary;\n\n/**\n * Checks for binary data.\n *\n * Right now only Buffer and ArrayBuffer are supported..\n *\n * @param {Object} anything\n * @api public\n */\n\nfunction hasBinary(data) {\n\n function _hasBinary(obj) {\n if (!obj) return false;\n\n if ( (global.Buffer && global.Buffer.isBuffer(obj)) ||\n (global.ArrayBuffer && obj instanceof ArrayBuffer) ||\n (global.Blob && obj instanceof Blob) ||\n (global.File && obj instanceof File)\n ) {\n return true;\n }\n\n if (isArray(obj)) {\n for (var i = 0; i < obj.length; i++) {\n if (_hasBinary(obj[i])) {\n return true;\n }\n }\n } else if (obj && 'object' == typeof obj) {\n if (obj.toJSON) {\n obj = obj.toJSON();\n }\n\n for (var key in obj) {\n if (obj.hasOwnProperty(key) && _hasBinary(obj[key])) {\n return true;\n }\n }\n }\n\n return false;\n }\n\n return _hasBinary(data);\n}\n\n/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))\n\n/*****************\n ** WEBPACK FOOTER\n ** (webpack)-dev-server/~/socket.io-client/~/engine.io-client/~/engine.io-parser/~/has-binary/index.js\n ** module id = 28\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///(webpack)-dev-server/~/socket.io-client/~/engine.io-client/~/engine.io-parser/~/has-binary/index.js?");
|
||
|
||
/***/ },
|
||
/* 29 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("module.exports = Array.isArray || function (arr) {\n return Object.prototype.toString.call(arr) == '[object Array]';\n};\n\n\n/*****************\n ** WEBPACK FOOTER\n ** (webpack)-dev-server/~/socket.io-client/~/engine.io-client/~/engine.io-parser/~/has-binary/~/isarray/index.js\n ** module id = 29\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///(webpack)-dev-server/~/socket.io-client/~/engine.io-client/~/engine.io-parser/~/has-binary/~/isarray/index.js?");
|
||
|
||
/***/ },
|
||
/* 30 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("/**\n * An abstraction for slicing an arraybuffer even when\n * ArrayBuffer.prototype.slice is not supported\n *\n * @api public\n */\n\nmodule.exports = function(arraybuffer, start, end) {\n var bytes = arraybuffer.byteLength;\n start = start || 0;\n end = end || bytes;\n\n if (arraybuffer.slice) { return arraybuffer.slice(start, end); }\n\n if (start < 0) { start += bytes; }\n if (end < 0) { end += bytes; }\n if (end > bytes) { end = bytes; }\n\n if (start >= bytes || start >= end || bytes === 0) {\n return new ArrayBuffer(0);\n }\n\n var abv = new Uint8Array(arraybuffer);\n var result = new Uint8Array(end - start);\n for (var i = start, ii = 0; i < end; i++, ii++) {\n result[ii] = abv[i];\n }\n return result.buffer;\n};\n\n\n/*****************\n ** WEBPACK FOOTER\n ** (webpack)-dev-server/~/socket.io-client/~/engine.io-client/~/engine.io-parser/~/arraybuffer.slice/index.js\n ** module id = 30\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///(webpack)-dev-server/~/socket.io-client/~/engine.io-client/~/engine.io-parser/~/arraybuffer.slice/index.js?");
|
||
|
||
/***/ },
|
||
/* 31 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("/*\n * base64-arraybuffer\n * https://github.com/niklasvh/base64-arraybuffer\n *\n * Copyright (c) 2012 Niklas von Hertzen\n * Licensed under the MIT license.\n */\n(function(chars){\n \"use strict\";\n\n exports.encode = function(arraybuffer) {\n var bytes = new Uint8Array(arraybuffer),\n i, len = bytes.length, base64 = \"\";\n\n for (i = 0; i < len; i+=3) {\n base64 += chars[bytes[i] >> 2];\n base64 += chars[((bytes[i] & 3) << 4) | (bytes[i + 1] >> 4)];\n base64 += chars[((bytes[i + 1] & 15) << 2) | (bytes[i + 2] >> 6)];\n base64 += chars[bytes[i + 2] & 63];\n }\n\n if ((len % 3) === 2) {\n base64 = base64.substring(0, base64.length - 1) + \"=\";\n } else if (len % 3 === 1) {\n base64 = base64.substring(0, base64.length - 2) + \"==\";\n }\n\n return base64;\n };\n\n exports.decode = function(base64) {\n var bufferLength = base64.length * 0.75,\n len = base64.length, i, p = 0,\n encoded1, encoded2, encoded3, encoded4;\n\n if (base64[base64.length - 1] === \"=\") {\n bufferLength--;\n if (base64[base64.length - 2] === \"=\") {\n bufferLength--;\n }\n }\n\n var arraybuffer = new ArrayBuffer(bufferLength),\n bytes = new Uint8Array(arraybuffer);\n\n for (i = 0; i < len; i+=4) {\n encoded1 = chars.indexOf(base64[i]);\n encoded2 = chars.indexOf(base64[i+1]);\n encoded3 = chars.indexOf(base64[i+2]);\n encoded4 = chars.indexOf(base64[i+3]);\n\n bytes[p++] = (encoded1 << 2) | (encoded2 >> 4);\n bytes[p++] = ((encoded2 & 15) << 4) | (encoded3 >> 2);\n bytes[p++] = ((encoded3 & 3) << 6) | (encoded4 & 63);\n }\n\n return arraybuffer;\n };\n})(\"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\");\n\n\n/*****************\n ** WEBPACK FOOTER\n ** (webpack)-dev-server/~/socket.io-client/~/engine.io-client/~/engine.io-parser/~/base64-arraybuffer/lib/base64-arraybuffer.js\n ** module id = 31\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///(webpack)-dev-server/~/socket.io-client/~/engine.io-client/~/engine.io-parser/~/base64-arraybuffer/lib/base64-arraybuffer.js?");
|
||
|
||
/***/ },
|
||
/* 32 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("module.exports = after\n\nfunction after(count, callback, err_cb) {\n var bail = false\n err_cb = err_cb || noop\n proxy.count = count\n\n return (count === 0) ? callback() : proxy\n\n function proxy(err, result) {\n if (proxy.count <= 0) {\n throw new Error('after called too many times')\n }\n --proxy.count\n\n // after first error, rest are passed to err_cb\n if (err) {\n bail = true\n callback(err)\n // future error callbacks will go to error handler\n callback = err_cb\n } else if (proxy.count === 0 && !bail) {\n callback(null, result)\n }\n }\n}\n\nfunction noop() {}\n\n\n/*****************\n ** WEBPACK FOOTER\n ** (webpack)-dev-server/~/socket.io-client/~/engine.io-client/~/engine.io-parser/~/after/index.js\n ** module id = 32\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///(webpack)-dev-server/~/socket.io-client/~/engine.io-client/~/engine.io-parser/~/after/index.js?");
|
||
|
||
/***/ },
|
||
/* 33 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("var __WEBPACK_AMD_DEFINE_RESULT__;/* WEBPACK VAR INJECTION */(function(module, global) {/*! http://mths.be/utf8js v2.0.0 by @mathias */\n;(function(root) {\n\n\t// Detect free variables `exports`\n\tvar freeExports = typeof exports == 'object' && exports;\n\n\t// Detect free variable `module`\n\tvar freeModule = typeof module == 'object' && module &&\n\t\tmodule.exports == freeExports && module;\n\n\t// Detect free variable `global`, from Node.js or Browserified code,\n\t// and use it as `root`\n\tvar freeGlobal = typeof global == 'object' && global;\n\tif (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {\n\t\troot = freeGlobal;\n\t}\n\n\t/*--------------------------------------------------------------------------*/\n\n\tvar stringFromCharCode = String.fromCharCode;\n\n\t// Taken from http://mths.be/punycode\n\tfunction ucs2decode(string) {\n\t\tvar output = [];\n\t\tvar counter = 0;\n\t\tvar length = string.length;\n\t\tvar value;\n\t\tvar extra;\n\t\twhile (counter < length) {\n\t\t\tvalue = string.charCodeAt(counter++);\n\t\t\tif (value >= 0xD800 && value <= 0xDBFF && counter < length) {\n\t\t\t\t// high surrogate, and there is a next character\n\t\t\t\textra = string.charCodeAt(counter++);\n\t\t\t\tif ((extra & 0xFC00) == 0xDC00) { // low surrogate\n\t\t\t\t\toutput.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);\n\t\t\t\t} else {\n\t\t\t\t\t// unmatched surrogate; only append this code unit, in case the next\n\t\t\t\t\t// code unit is the high surrogate of a surrogate pair\n\t\t\t\t\toutput.push(value);\n\t\t\t\t\tcounter--;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\toutput.push(value);\n\t\t\t}\n\t\t}\n\t\treturn output;\n\t}\n\n\t// Taken from http://mths.be/punycode\n\tfunction ucs2encode(array) {\n\t\tvar length = array.length;\n\t\tvar index = -1;\n\t\tvar value;\n\t\tvar output = '';\n\t\twhile (++index < length) {\n\t\t\tvalue = array[index];\n\t\t\tif (value > 0xFFFF) {\n\t\t\t\tvalue -= 0x10000;\n\t\t\t\toutput += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);\n\t\t\t\tvalue = 0xDC00 | value & 0x3FF;\n\t\t\t}\n\t\t\toutput += stringFromCharCode(value);\n\t\t}\n\t\treturn output;\n\t}\n\n\t/*--------------------------------------------------------------------------*/\n\n\tfunction createByte(codePoint, shift) {\n\t\treturn stringFromCharCode(((codePoint >> shift) & 0x3F) | 0x80);\n\t}\n\n\tfunction encodeCodePoint(codePoint) {\n\t\tif ((codePoint & 0xFFFFFF80) == 0) { // 1-byte sequence\n\t\t\treturn stringFromCharCode(codePoint);\n\t\t}\n\t\tvar symbol = '';\n\t\tif ((codePoint & 0xFFFFF800) == 0) { // 2-byte sequence\n\t\t\tsymbol = stringFromCharCode(((codePoint >> 6) & 0x1F) | 0xC0);\n\t\t}\n\t\telse if ((codePoint & 0xFFFF0000) == 0) { // 3-byte sequence\n\t\t\tsymbol = stringFromCharCode(((codePoint >> 12) & 0x0F) | 0xE0);\n\t\t\tsymbol += createByte(codePoint, 6);\n\t\t}\n\t\telse if ((codePoint & 0xFFE00000) == 0) { // 4-byte sequence\n\t\t\tsymbol = stringFromCharCode(((codePoint >> 18) & 0x07) | 0xF0);\n\t\t\tsymbol += createByte(codePoint, 12);\n\t\t\tsymbol += createByte(codePoint, 6);\n\t\t}\n\t\tsymbol += stringFromCharCode((codePoint & 0x3F) | 0x80);\n\t\treturn symbol;\n\t}\n\n\tfunction utf8encode(string) {\n\t\tvar codePoints = ucs2decode(string);\n\n\t\t// console.log(JSON.stringify(codePoints.map(function(x) {\n\t\t// \treturn 'U+' + x.toString(16).toUpperCase();\n\t\t// })));\n\n\t\tvar length = codePoints.length;\n\t\tvar index = -1;\n\t\tvar codePoint;\n\t\tvar byteString = '';\n\t\twhile (++index < length) {\n\t\t\tcodePoint = codePoints[index];\n\t\t\tbyteString += encodeCodePoint(codePoint);\n\t\t}\n\t\treturn byteString;\n\t}\n\n\t/*--------------------------------------------------------------------------*/\n\n\tfunction readContinuationByte() {\n\t\tif (byteIndex >= byteCount) {\n\t\t\tthrow Error('Invalid byte index');\n\t\t}\n\n\t\tvar continuationByte = byteArray[byteIndex] & 0xFF;\n\t\tbyteIndex++;\n\n\t\tif ((continuationByte & 0xC0) == 0x80) {\n\t\t\treturn continuationByte & 0x3F;\n\t\t}\n\n\t\t// If we end up here, it’s not a continuation byte\n\t\tthrow Error('Invalid continuation byte');\n\t}\n\n\tfunction decodeSymbol() {\n\t\tvar byte1;\n\t\tvar byte2;\n\t\tvar byte3;\n\t\tvar byte4;\n\t\tvar codePoint;\n\n\t\tif (byteIndex > byteCount) {\n\t\t\tthrow Error('Invalid byte index');\n\t\t}\n\n\t\tif (byteIndex == byteCount) {\n\t\t\treturn false;\n\t\t}\n\n\t\t// Read first byte\n\t\tbyte1 = byteArray[byteIndex] & 0xFF;\n\t\tbyteIndex++;\n\n\t\t// 1-byte sequence (no continuation bytes)\n\t\tif ((byte1 & 0x80) == 0) {\n\t\t\treturn byte1;\n\t\t}\n\n\t\t// 2-byte sequence\n\t\tif ((byte1 & 0xE0) == 0xC0) {\n\t\t\tvar byte2 = readContinuationByte();\n\t\t\tcodePoint = ((byte1 & 0x1F) << 6) | byte2;\n\t\t\tif (codePoint >= 0x80) {\n\t\t\t\treturn codePoint;\n\t\t\t} else {\n\t\t\t\tthrow Error('Invalid continuation byte');\n\t\t\t}\n\t\t}\n\n\t\t// 3-byte sequence (may include unpaired surrogates)\n\t\tif ((byte1 & 0xF0) == 0xE0) {\n\t\t\tbyte2 = readContinuationByte();\n\t\t\tbyte3 = readContinuationByte();\n\t\t\tcodePoint = ((byte1 & 0x0F) << 12) | (byte2 << 6) | byte3;\n\t\t\tif (codePoint >= 0x0800) {\n\t\t\t\treturn codePoint;\n\t\t\t} else {\n\t\t\t\tthrow Error('Invalid continuation byte');\n\t\t\t}\n\t\t}\n\n\t\t// 4-byte sequence\n\t\tif ((byte1 & 0xF8) == 0xF0) {\n\t\t\tbyte2 = readContinuationByte();\n\t\t\tbyte3 = readContinuationByte();\n\t\t\tbyte4 = readContinuationByte();\n\t\t\tcodePoint = ((byte1 & 0x0F) << 0x12) | (byte2 << 0x0C) |\n\t\t\t\t(byte3 << 0x06) | byte4;\n\t\t\tif (codePoint >= 0x010000 && codePoint <= 0x10FFFF) {\n\t\t\t\treturn codePoint;\n\t\t\t}\n\t\t}\n\n\t\tthrow Error('Invalid UTF-8 detected');\n\t}\n\n\tvar byteArray;\n\tvar byteCount;\n\tvar byteIndex;\n\tfunction utf8decode(byteString) {\n\t\tbyteArray = ucs2decode(byteString);\n\t\tbyteCount = byteArray.length;\n\t\tbyteIndex = 0;\n\t\tvar codePoints = [];\n\t\tvar tmp;\n\t\twhile ((tmp = decodeSymbol()) !== false) {\n\t\t\tcodePoints.push(tmp);\n\t\t}\n\t\treturn ucs2encode(codePoints);\n\t}\n\n\t/*--------------------------------------------------------------------------*/\n\n\tvar utf8 = {\n\t\t'version': '2.0.0',\n\t\t'encode': utf8encode,\n\t\t'decode': utf8decode\n\t};\n\n\t// Some AMD build optimizers, like r.js, check for specific condition patterns\n\t// like the following:\n\tif (\n\t\ttrue\n\t) {\n\t\t!(__WEBPACK_AMD_DEFINE_RESULT__ = function() {\n\t\t\treturn utf8;\n\t\t}.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n\t}\telse if (freeExports && !freeExports.nodeType) {\n\t\tif (freeModule) { // in Node.js or RingoJS v0.8.0+\n\t\t\tfreeModule.exports = utf8;\n\t\t} else { // in Narwhal or RingoJS v0.7.0-\n\t\t\tvar object = {};\n\t\t\tvar hasOwnProperty = object.hasOwnProperty;\n\t\t\tfor (var key in utf8) {\n\t\t\t\thasOwnProperty.call(utf8, key) && (freeExports[key] = utf8[key]);\n\t\t\t}\n\t\t}\n\t} else { // in Rhino or a web browser\n\t\troot.utf8 = utf8;\n\t}\n\n}(this));\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(34)(module), (function() { return this; }())))\n\n/*****************\n ** WEBPACK FOOTER\n ** (webpack)-dev-server/~/socket.io-client/~/engine.io-client/~/engine.io-parser/~/utf8/utf8.js\n ** module id = 33\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///(webpack)-dev-server/~/socket.io-client/~/engine.io-client/~/engine.io-parser/~/utf8/utf8.js?");
|
||
|
||
/***/ },
|
||
/* 34 */
|
||
/***/ function(module, exports) {
|
||
|
||
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 = 34\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///(webpack)/buildin/module.js?");
|
||
|
||
/***/ },
|
||
/* 35 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("/* WEBPACK VAR INJECTION */(function(global) {/**\n * Create a blob builder even when vendor prefixes exist\n */\n\nvar BlobBuilder = global.BlobBuilder\n || global.WebKitBlobBuilder\n || global.MSBlobBuilder\n || global.MozBlobBuilder;\n\n/**\n * Check if Blob constructor is supported\n */\n\nvar blobSupported = (function() {\n try {\n var b = new Blob(['hi']);\n return b.size == 2;\n } catch(e) {\n return false;\n }\n})();\n\n/**\n * Check if BlobBuilder is supported\n */\n\nvar blobBuilderSupported = BlobBuilder\n && BlobBuilder.prototype.append\n && BlobBuilder.prototype.getBlob;\n\nfunction BlobBuilderConstructor(ary, options) {\n options = options || {};\n\n var bb = new BlobBuilder();\n for (var i = 0; i < ary.length; i++) {\n bb.append(ary[i]);\n }\n return (options.type) ? bb.getBlob(options.type) : bb.getBlob();\n};\n\nmodule.exports = (function() {\n if (blobSupported) {\n return global.Blob;\n } else if (blobBuilderSupported) {\n return BlobBuilderConstructor;\n } else {\n return undefined;\n }\n})();\n\n/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))\n\n/*****************\n ** WEBPACK FOOTER\n ** (webpack)-dev-server/~/socket.io-client/~/engine.io-client/~/engine.io-parser/~/blob/index.js\n ** module id = 35\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///(webpack)-dev-server/~/socket.io-client/~/engine.io-client/~/engine.io-parser/~/blob/index.js?");
|
||
|
||
/***/ },
|
||
/* 36 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("/**\n * Compiles a querystring\n * Returns string representation of the object\n *\n * @param {Object}\n * @api private\n */\n\nexports.encode = function (obj) {\n var str = '';\n\n for (var i in obj) {\n if (obj.hasOwnProperty(i)) {\n if (str.length) str += '&';\n str += encodeURIComponent(i) + '=' + encodeURIComponent(obj[i]);\n }\n }\n\n return str;\n};\n\n/**\n * Parses a simple querystring into an object\n *\n * @param {String} qs\n * @api private\n */\n\nexports.decode = function(qs){\n var qry = {};\n var pairs = qs.split('&');\n for (var i = 0, l = pairs.length; i < l; i++) {\n var pair = pairs[i].split('=');\n qry[decodeURIComponent(pair[0])] = decodeURIComponent(pair[1]);\n }\n return qry;\n};\n\n\n/*****************\n ** WEBPACK FOOTER\n ** (webpack)-dev-server/~/socket.io-client/~/engine.io-client/~/parseqs/index.js\n ** module id = 36\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///(webpack)-dev-server/~/socket.io-client/~/engine.io-client/~/parseqs/index.js?");
|
||
|
||
/***/ },
|
||
/* 37 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("\n/**\n * This is the web browser implementation of `debug()`.\n *\n * Expose `debug()` as the module.\n */\n\nexports = module.exports = __webpack_require__(38);\nexports.log = log;\nexports.formatArgs = formatArgs;\nexports.save = save;\nexports.load = load;\nexports.useColors = useColors;\n\n/**\n * Colors.\n */\n\nexports.colors = [\n 'lightseagreen',\n 'forestgreen',\n 'goldenrod',\n 'dodgerblue',\n 'darkorchid',\n 'crimson'\n];\n\n/**\n * Currently only WebKit-based Web Inspectors, Firefox >= v31,\n * and the Firebug extension (any Firefox version) are known\n * to support \"%c\" CSS customizations.\n *\n * TODO: add a `localStorage` variable to explicitly enable/disable colors\n */\n\nfunction useColors() {\n // is webkit? http://stackoverflow.com/a/16459606/376773\n return ('WebkitAppearance' in document.documentElement.style) ||\n // is firebug? http://stackoverflow.com/a/398120/376773\n (window.console && (console.firebug || (console.exception && console.table))) ||\n // is firefox >= v31?\n // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages\n (navigator.userAgent.toLowerCase().match(/firefox\\/(\\d+)/) && parseInt(RegExp.$1, 10) >= 31);\n}\n\n/**\n * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.\n */\n\nexports.formatters.j = function(v) {\n return JSON.stringify(v);\n};\n\n\n/**\n * Colorize log arguments if enabled.\n *\n * @api public\n */\n\nfunction formatArgs() {\n var args = arguments;\n var useColors = this.useColors;\n\n args[0] = (useColors ? '%c' : '')\n + this.namespace\n + (useColors ? ' %c' : ' ')\n + args[0]\n + (useColors ? '%c ' : ' ')\n + '+' + exports.humanize(this.diff);\n\n if (!useColors) return args;\n\n var c = 'color: ' + this.color;\n args = [args[0], c, 'color: inherit'].concat(Array.prototype.slice.call(args, 1));\n\n // the final \"%c\" is somewhat tricky, because there could be other\n // arguments passed either before or after the %c, so we need to\n // figure out the correct index to insert the CSS into\n var index = 0;\n var lastC = 0;\n args[0].replace(/%[a-z%]/g, function(match) {\n if ('%%' === match) return;\n index++;\n if ('%c' === match) {\n // we only are interested in the *last* %c\n // (the user may have provided their own)\n lastC = index;\n }\n });\n\n args.splice(lastC, 0, c);\n return args;\n}\n\n/**\n * Invokes `console.log()` when available.\n * No-op when `console.log` is not a \"function\".\n *\n * @api public\n */\n\nfunction log() {\n // This hackery is required for IE8,\n // where the `console.log` function doesn't have 'apply'\n return 'object' == typeof console\n && 'function' == typeof console.log\n && Function.prototype.apply.call(console.log, console, arguments);\n}\n\n/**\n * Save `namespaces`.\n *\n * @param {String} namespaces\n * @api private\n */\n\nfunction save(namespaces) {\n try {\n if (null == namespaces) {\n localStorage.removeItem('debug');\n } else {\n localStorage.debug = namespaces;\n }\n } catch(e) {}\n}\n\n/**\n * Load `namespaces`.\n *\n * @return {String} returns the previously persisted debug modes\n * @api private\n */\n\nfunction load() {\n var r;\n try {\n r = localStorage.debug;\n } catch(e) {}\n return r;\n}\n\n/**\n * Enable namespaces listed in `localStorage.debug` initially.\n */\n\nexports.enable(load());\n\n\n/*****************\n ** WEBPACK FOOTER\n ** (webpack)-dev-server/~/socket.io-client/~/engine.io-client/~/debug/browser.js\n ** module id = 37\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///(webpack)-dev-server/~/socket.io-client/~/engine.io-client/~/debug/browser.js?");
|
||
|
||
/***/ },
|
||
/* 38 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("\n/**\n * This is the common logic for both the Node.js and web browser\n * implementations of `debug()`.\n *\n * Expose `debug()` as the module.\n */\n\nexports = module.exports = debug;\nexports.coerce = coerce;\nexports.disable = disable;\nexports.enable = enable;\nexports.enabled = enabled;\nexports.humanize = __webpack_require__(39);\n\n/**\n * The currently active debug mode names, and names to skip.\n */\n\nexports.names = [];\nexports.skips = [];\n\n/**\n * Map of special \"%n\" handling functions, for the debug \"format\" argument.\n *\n * Valid key names are a single, lowercased letter, i.e. \"n\".\n */\n\nexports.formatters = {};\n\n/**\n * Previously assigned color.\n */\n\nvar prevColor = 0;\n\n/**\n * Previous log timestamp.\n */\n\nvar prevTime;\n\n/**\n * Select a color.\n *\n * @return {Number}\n * @api private\n */\n\nfunction selectColor() {\n return exports.colors[prevColor++ % exports.colors.length];\n}\n\n/**\n * Create a debugger with the given `namespace`.\n *\n * @param {String} namespace\n * @return {Function}\n * @api public\n */\n\nfunction debug(namespace) {\n\n // define the `disabled` version\n function disabled() {\n }\n disabled.enabled = false;\n\n // define the `enabled` version\n function enabled() {\n\n var self = enabled;\n\n // set `diff` timestamp\n var curr = +new Date();\n var ms = curr - (prevTime || curr);\n self.diff = ms;\n self.prev = prevTime;\n self.curr = curr;\n prevTime = curr;\n\n // add the `color` if not set\n if (null == self.useColors) self.useColors = exports.useColors();\n if (null == self.color && self.useColors) self.color = selectColor();\n\n var args = Array.prototype.slice.call(arguments);\n\n args[0] = exports.coerce(args[0]);\n\n if ('string' !== typeof args[0]) {\n // anything else let's inspect with %o\n args = ['%o'].concat(args);\n }\n\n // apply any `formatters` transformations\n var index = 0;\n args[0] = args[0].replace(/%([a-z%])/g, function(match, format) {\n // if we encounter an escaped % then don't increase the array index\n if (match === '%%') return match;\n index++;\n var formatter = exports.formatters[format];\n if ('function' === typeof formatter) {\n var val = args[index];\n match = formatter.call(self, val);\n\n // now we need to remove `args[index]` since it's inlined in the `format`\n args.splice(index, 1);\n index--;\n }\n return match;\n });\n\n if ('function' === typeof exports.formatArgs) {\n args = exports.formatArgs.apply(self, args);\n }\n var logFn = enabled.log || exports.log || console.log.bind(console);\n logFn.apply(self, args);\n }\n enabled.enabled = true;\n\n var fn = exports.enabled(namespace) ? enabled : disabled;\n\n fn.namespace = namespace;\n\n return fn;\n}\n\n/**\n * Enables a debug mode by namespaces. This can include modes\n * separated by a colon and wildcards.\n *\n * @param {String} namespaces\n * @api public\n */\n\nfunction enable(namespaces) {\n exports.save(namespaces);\n\n var split = (namespaces || '').split(/[\\s,]+/);\n var len = split.length;\n\n for (var i = 0; i < len; i++) {\n if (!split[i]) continue; // ignore empty strings\n namespaces = split[i].replace(/\\*/g, '.*?');\n if (namespaces[0] === '-') {\n exports.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));\n } else {\n exports.names.push(new RegExp('^' + namespaces + '$'));\n }\n }\n}\n\n/**\n * Disable debug output.\n *\n * @api public\n */\n\nfunction disable() {\n exports.enable('');\n}\n\n/**\n * Returns true if the given mode name is enabled, false otherwise.\n *\n * @param {String} name\n * @return {Boolean}\n * @api public\n */\n\nfunction enabled(name) {\n var i, len;\n for (i = 0, len = exports.skips.length; i < len; i++) {\n if (exports.skips[i].test(name)) {\n return false;\n }\n }\n for (i = 0, len = exports.names.length; i < len; i++) {\n if (exports.names[i].test(name)) {\n return true;\n }\n }\n return false;\n}\n\n/**\n * Coerce `val`.\n *\n * @param {Mixed} val\n * @return {Mixed}\n * @api private\n */\n\nfunction coerce(val) {\n if (val instanceof Error) return val.stack || val.message;\n return val;\n}\n\n\n/*****************\n ** WEBPACK FOOTER\n ** (webpack)-dev-server/~/socket.io-client/~/engine.io-client/~/debug/debug.js\n ** module id = 38\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///(webpack)-dev-server/~/socket.io-client/~/engine.io-client/~/debug/debug.js?");
|
||
|
||
/***/ },
|
||
/* 39 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("/**\n * Helpers.\n */\n\nvar s = 1000;\nvar m = s * 60;\nvar h = m * 60;\nvar d = h * 24;\nvar y = d * 365.25;\n\n/**\n * Parse or format the given `val`.\n *\n * Options:\n *\n * - `long` verbose formatting [false]\n *\n * @param {String|Number} val\n * @param {Object} options\n * @return {String|Number}\n * @api public\n */\n\nmodule.exports = function(val, options){\n options = options || {};\n if ('string' == typeof val) return parse(val);\n return options.long\n ? long(val)\n : short(val);\n};\n\n/**\n * Parse the given `str` and return milliseconds.\n *\n * @param {String} str\n * @return {Number}\n * @api private\n */\n\nfunction parse(str) {\n var match = /^((?:\\d+)?\\.?\\d+) *(ms|seconds?|s|minutes?|m|hours?|h|days?|d|years?|y)?$/i.exec(str);\n if (!match) return;\n var n = parseFloat(match[1]);\n var type = (match[2] || 'ms').toLowerCase();\n switch (type) {\n case 'years':\n case 'year':\n case 'y':\n return n * y;\n case 'days':\n case 'day':\n case 'd':\n return n * d;\n case 'hours':\n case 'hour':\n case 'h':\n return n * h;\n case 'minutes':\n case 'minute':\n case 'm':\n return n * m;\n case 'seconds':\n case 'second':\n case 's':\n return n * s;\n case 'ms':\n return n;\n }\n}\n\n/**\n * Short format for `ms`.\n *\n * @param {Number} ms\n * @return {String}\n * @api private\n */\n\nfunction short(ms) {\n if (ms >= d) return Math.round(ms / d) + 'd';\n if (ms >= h) return Math.round(ms / h) + 'h';\n if (ms >= m) return Math.round(ms / m) + 'm';\n if (ms >= s) return Math.round(ms / s) + 's';\n return ms + 'ms';\n}\n\n/**\n * Long format for `ms`.\n *\n * @param {Number} ms\n * @return {String}\n * @api private\n */\n\nfunction long(ms) {\n return plural(ms, d, 'day')\n || plural(ms, h, 'hour')\n || plural(ms, m, 'minute')\n || plural(ms, s, 'second')\n || ms + ' ms';\n}\n\n/**\n * Pluralization helper.\n */\n\nfunction plural(ms, n, name) {\n if (ms < n) return;\n if (ms < n * 1.5) return Math.floor(ms / n) + ' ' + name;\n return Math.ceil(ms / n) + ' ' + name + 's';\n}\n\n\n/*****************\n ** WEBPACK FOOTER\n ** (webpack)-dev-server/~/socket.io-client/~/engine.io-client/~/debug/~/ms/index.js\n ** module id = 39\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///(webpack)-dev-server/~/socket.io-client/~/engine.io-client/~/debug/~/ms/index.js?");
|
||
|
||
/***/ },
|
||
/* 40 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/* WEBPACK VAR INJECTION */(function(global) {\n/**\n * Module requirements.\n */\n\nvar Polling = __webpack_require__(23);\nvar inherit = __webpack_require__(24);\n\n/**\n * Module exports.\n */\n\nmodule.exports = JSONPPolling;\n\n/**\n * Cached regular expressions.\n */\n\nvar rNewline = /\\n/g;\nvar rEscapedNewline = /\\\\n/g;\n\n/**\n * Global JSONP callbacks.\n */\n\nvar callbacks;\n\n/**\n * Callbacks count.\n */\n\nvar index = 0;\n\n/**\n * Noop.\n */\n\nfunction empty () { }\n\n/**\n * JSONP Polling constructor.\n *\n * @param {Object} opts.\n * @api public\n */\n\nfunction JSONPPolling (opts) {\n Polling.call(this, opts);\n\n this.query = this.query || {};\n\n // define global callbacks array if not present\n // we do this here (lazily) to avoid unneeded global pollution\n if (!callbacks) {\n // we need to consider multiple engines in the same page\n if (!global.___eio) global.___eio = [];\n callbacks = global.___eio;\n }\n\n // callback identifier\n this.index = callbacks.length;\n\n // add callback to jsonp global\n var self = this;\n callbacks.push(function (msg) {\n self.onData(msg);\n });\n\n // append to query string\n this.query.j = this.index;\n\n // prevent spurious errors from being emitted when the window is unloaded\n if (global.document && global.addEventListener) {\n global.addEventListener('beforeunload', function () {\n if (self.script) self.script.onerror = empty;\n }, false);\n }\n}\n\n/**\n * Inherits from Polling.\n */\n\ninherit(JSONPPolling, Polling);\n\n/*\n * JSONP only supports binary as base64 encoded strings\n */\n\nJSONPPolling.prototype.supportsBinary = false;\n\n/**\n * Closes the socket.\n *\n * @api private\n */\n\nJSONPPolling.prototype.doClose = function () {\n if (this.script) {\n this.script.parentNode.removeChild(this.script);\n this.script = null;\n }\n\n if (this.form) {\n this.form.parentNode.removeChild(this.form);\n this.form = null;\n this.iframe = null;\n }\n\n Polling.prototype.doClose.call(this);\n};\n\n/**\n * Starts a poll cycle.\n *\n * @api private\n */\n\nJSONPPolling.prototype.doPoll = function () {\n var self = this;\n var script = document.createElement('script');\n\n if (this.script) {\n this.script.parentNode.removeChild(this.script);\n this.script = null;\n }\n\n script.async = true;\n script.src = this.uri();\n script.onerror = function(e){\n self.onError('jsonp poll error',e);\n };\n\n var insertAt = document.getElementsByTagName('script')[0];\n insertAt.parentNode.insertBefore(script, insertAt);\n this.script = script;\n\n var isUAgecko = 'undefined' != typeof navigator && /gecko/i.test(navigator.userAgent);\n \n if (isUAgecko) {\n setTimeout(function () {\n var iframe = document.createElement('iframe');\n document.body.appendChild(iframe);\n document.body.removeChild(iframe);\n }, 100);\n }\n};\n\n/**\n * Writes with a hidden iframe.\n *\n * @param {String} data to send\n * @param {Function} called upon flush.\n * @api private\n */\n\nJSONPPolling.prototype.doWrite = function (data, fn) {\n var self = this;\n\n if (!this.form) {\n var form = document.createElement('form');\n var area = document.createElement('textarea');\n var id = this.iframeId = 'eio_iframe_' + this.index;\n var iframe;\n\n form.className = 'socketio';\n form.style.position = 'absolute';\n form.style.top = '-1000px';\n form.style.left = '-1000px';\n form.target = id;\n form.method = 'POST';\n form.setAttribute('accept-charset', 'utf-8');\n area.name = 'd';\n form.appendChild(area);\n document.body.appendChild(form);\n\n this.form = form;\n this.area = area;\n }\n\n this.form.action = this.uri();\n\n function complete () {\n initIframe();\n fn();\n }\n\n function initIframe () {\n if (self.iframe) {\n try {\n self.form.removeChild(self.iframe);\n } catch (e) {\n self.onError('jsonp polling iframe removal error', e);\n }\n }\n\n try {\n // ie6 dynamic iframes with target=\"\" support (thanks Chris Lambacher)\n var html = '<iframe src=\"javascript:0\" name=\"'+ self.iframeId +'\">';\n iframe = document.createElement(html);\n } catch (e) {\n iframe = document.createElement('iframe');\n iframe.name = self.iframeId;\n iframe.src = 'javascript:0';\n }\n\n iframe.id = self.iframeId;\n\n self.form.appendChild(iframe);\n self.iframe = iframe;\n }\n\n initIframe();\n\n // escape \\n to prevent it from being converted into \\r\\n by some UAs\n // double escaping is required for escaped new lines because unescaping of new lines can be done safely on server-side\n data = data.replace(rEscapedNewline, '\\\\\\n');\n this.area.value = data.replace(rNewline, '\\\\n');\n\n try {\n this.form.submit();\n } catch(e) {}\n\n if (this.iframe.attachEvent) {\n this.iframe.onreadystatechange = function(){\n if (self.iframe.readyState == 'complete') {\n complete();\n }\n };\n } else {\n this.iframe.onload = complete;\n }\n};\n\n/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))\n\n/*****************\n ** WEBPACK FOOTER\n ** (webpack)-dev-server/~/socket.io-client/~/engine.io-client/lib/transports/polling-jsonp.js\n ** module id = 40\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///(webpack)-dev-server/~/socket.io-client/~/engine.io-client/lib/transports/polling-jsonp.js?");
|
||
|
||
/***/ },
|
||
/* 41 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\n * Module dependencies.\n */\n\nvar Transport = __webpack_require__(25);\nvar parser = __webpack_require__(26);\nvar parseqs = __webpack_require__(36);\nvar inherit = __webpack_require__(24);\nvar debug = __webpack_require__(37)('engine.io-client:websocket');\n\n/**\n * `ws` exposes a WebSocket-compatible interface in\n * Node, or the `WebSocket` or `MozWebSocket` globals\n * in the browser.\n */\n\nvar WebSocket = __webpack_require__(42);\n\n/**\n * Module exports.\n */\n\nmodule.exports = WS;\n\n/**\n * WebSocket transport constructor.\n *\n * @api {Object} connection options\n * @api public\n */\n\nfunction WS(opts){\n var forceBase64 = (opts && opts.forceBase64);\n if (forceBase64) {\n this.supportsBinary = false;\n }\n Transport.call(this, opts);\n}\n\n/**\n * Inherits from Transport.\n */\n\ninherit(WS, Transport);\n\n/**\n * Transport name.\n *\n * @api public\n */\n\nWS.prototype.name = 'websocket';\n\n/*\n * WebSockets support binary\n */\n\nWS.prototype.supportsBinary = true;\n\n/**\n * Opens socket.\n *\n * @api private\n */\n\nWS.prototype.doOpen = function(){\n if (!this.check()) {\n // let probe timeout\n return;\n }\n\n var self = this;\n var uri = this.uri();\n var protocols = void(0);\n var opts = { agent: this.agent };\n\n // SSL options for Node.js client\n opts.pfx = this.pfx;\n opts.key = this.key;\n opts.passphrase = this.passphrase;\n opts.cert = this.cert;\n opts.ca = this.ca;\n opts.ciphers = this.ciphers;\n opts.rejectUnauthorized = this.rejectUnauthorized;\n\n this.ws = new WebSocket(uri, protocols, opts);\n\n if (this.ws.binaryType === undefined) {\n this.supportsBinary = false;\n }\n\n this.ws.binaryType = 'arraybuffer';\n this.addEventListeners();\n};\n\n/**\n * Adds event listeners to the socket\n *\n * @api private\n */\n\nWS.prototype.addEventListeners = function(){\n var self = this;\n\n this.ws.onopen = function(){\n self.onOpen();\n };\n this.ws.onclose = function(){\n self.onClose();\n };\n this.ws.onmessage = function(ev){\n self.onData(ev.data);\n };\n this.ws.onerror = function(e){\n self.onError('websocket error', e);\n };\n};\n\n/**\n * Override `onData` to use a timer on iOS.\n * See: https://gist.github.com/mloughran/2052006\n *\n * @api private\n */\n\nif ('undefined' != typeof navigator\n && /iPad|iPhone|iPod/i.test(navigator.userAgent)) {\n WS.prototype.onData = function(data){\n var self = this;\n setTimeout(function(){\n Transport.prototype.onData.call(self, data);\n }, 0);\n };\n}\n\n/**\n * Writes data to socket.\n *\n * @param {Array} array of packets.\n * @api private\n */\n\nWS.prototype.write = function(packets){\n var self = this;\n this.writable = false;\n // encodePacket efficient as it uses WS framing\n // no need for encodePayload\n for (var i = 0, l = packets.length; i < l; i++) {\n parser.encodePacket(packets[i], this.supportsBinary, function(data) {\n //Sometimes the websocket has already been closed but the browser didn't\n //have a chance of informing us about it yet, in that case send will\n //throw an error\n try {\n self.ws.send(data);\n } catch (e){\n debug('websocket closed before onclose event');\n }\n });\n }\n\n function ondrain() {\n self.writable = true;\n self.emit('drain');\n }\n // fake drain\n // defer to next tick to allow Socket to clear writeBuffer\n setTimeout(ondrain, 0);\n};\n\n/**\n * Called upon close\n *\n * @api private\n */\n\nWS.prototype.onClose = function(){\n Transport.prototype.onClose.call(this);\n};\n\n/**\n * Closes socket.\n *\n * @api private\n */\n\nWS.prototype.doClose = function(){\n if (typeof this.ws !== 'undefined') {\n this.ws.close();\n }\n};\n\n/**\n * Generates uri for connection.\n *\n * @api private\n */\n\nWS.prototype.uri = function(){\n var query = this.query || {};\n var schema = this.secure ? 'wss' : 'ws';\n var port = '';\n\n // avoid port if default for schema\n if (this.port && (('wss' == schema && this.port != 443)\n || ('ws' == schema && this.port != 80))) {\n port = ':' + this.port;\n }\n\n // append timestamp to URI\n if (this.timestampRequests) {\n query[this.timestampParam] = +new Date;\n }\n\n // communicate binary support capabilities\n if (!this.supportsBinary) {\n query.b64 = 1;\n }\n\n query = parseqs.encode(query);\n\n // prepend ? to query\n if (query.length) {\n query = '?' + query;\n }\n\n return schema + '://' + this.hostname + port + this.path + query;\n};\n\n/**\n * Feature detection for WebSocket.\n *\n * @return {Boolean} whether this transport is available.\n * @api public\n */\n\nWS.prototype.check = function(){\n return !!WebSocket && !('__initialize' in WebSocket && this.name === WS.prototype.name);\n};\n\n\n/*****************\n ** WEBPACK FOOTER\n ** (webpack)-dev-server/~/socket.io-client/~/engine.io-client/lib/transports/websocket.js\n ** module id = 41\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///(webpack)-dev-server/~/socket.io-client/~/engine.io-client/lib/transports/websocket.js?");
|
||
|
||
/***/ },
|
||
/* 42 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("\n/**\n * Module dependencies.\n */\n\nvar global = (function() { return this; })();\n\n/**\n * WebSocket constructor.\n */\n\nvar WebSocket = global.WebSocket || global.MozWebSocket;\n\n/**\n * Module exports.\n */\n\nmodule.exports = WebSocket ? ws : null;\n\n/**\n * WebSocket constructor.\n *\n * The third `opts` options object gets ignored in web browsers, since it's\n * non-standard, and throws a TypeError if passed to the constructor.\n * See: https://github.com/einaros/ws/issues/227\n *\n * @param {String} uri\n * @param {Array} protocols (optional)\n * @param {Object) opts (optional)\n * @api public\n */\n\nfunction ws(uri, protocols, opts) {\n var instance;\n if (protocols) {\n instance = new WebSocket(uri, protocols);\n } else {\n instance = new WebSocket(uri);\n }\n return instance;\n}\n\nif (WebSocket) ws.prototype = WebSocket.prototype;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** (webpack)-dev-server/~/socket.io-client/~/engine.io-client/~/ws/lib/browser.js\n ** module id = 42\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///(webpack)-dev-server/~/socket.io-client/~/engine.io-client/~/ws/lib/browser.js?");
|
||
|
||
/***/ },
|
||
/* 43 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("\nvar indexOf = [].indexOf;\n\nmodule.exports = function(arr, obj){\n if (indexOf) return arr.indexOf(obj);\n for (var i = 0; i < arr.length; ++i) {\n if (arr[i] === obj) return i;\n }\n return -1;\n};\n\n/*****************\n ** WEBPACK FOOTER\n ** (webpack)-dev-server/~/socket.io-client/~/indexof/index.js\n ** module id = 43\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///(webpack)-dev-server/~/socket.io-client/~/indexof/index.js?");
|
||
|
||
/***/ },
|
||
/* 44 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("/**\n * Parses an URI\n *\n * @author Steven Levithan <stevenlevithan.com> (MIT license)\n * @api private\n */\n\nvar re = /^(?:(?![^:@]+:[^:@\\/]*@)(http|https|ws|wss):\\/\\/)?((?:(([^:@]*)(?::([^:@]*))?)?@)?((?:[a-f0-9]{0,4}:){2,7}[a-f0-9]{0,4}|[^:\\/?#]*)(?::(\\d*))?)(((\\/(?:[^?#](?![^?#\\/]*\\.[^?#\\/.]+(?:[?#]|$)))*\\/?)?([^?#\\/]*))(?:\\?([^#]*))?(?:#(.*))?)/;\n\nvar parts = [\n 'source', 'protocol', 'authority', 'userInfo', 'user', 'password', 'host', 'port', 'relative', 'path', 'directory', 'file', 'query', 'anchor'\n];\n\nmodule.exports = function parseuri(str) {\n var src = str,\n b = str.indexOf('['),\n e = str.indexOf(']');\n\n if (b != -1 && e != -1) {\n str = str.substring(0, b) + str.substring(b, e).replace(/:/g, ';') + str.substring(e, str.length);\n }\n\n var m = re.exec(str || ''),\n uri = {},\n i = 14;\n\n while (i--) {\n uri[parts[i]] = m[i] || '';\n }\n\n if (b != -1 && e != -1) {\n uri.source = src;\n uri.host = uri.host.substring(1, uri.host.length - 1).replace(/;/g, ':');\n uri.authority = uri.authority.replace('[', '').replace(']', '').replace(/;/g, ':');\n uri.ipv6uri = true;\n }\n\n return uri;\n};\n\n\n/*****************\n ** WEBPACK FOOTER\n ** (webpack)-dev-server/~/socket.io-client/~/engine.io-client/~/parseuri/index.js\n ** module id = 44\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///(webpack)-dev-server/~/socket.io-client/~/engine.io-client/~/parseuri/index.js?");
|
||
|
||
/***/ },
|
||
/* 45 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("/* WEBPACK VAR INJECTION */(function(global) {/**\n * JSON parse.\n *\n * @see Based on jQuery#parseJSON (MIT) and JSON2\n * @api private\n */\n\nvar rvalidchars = /^[\\],:{}\\s]*$/;\nvar rvalidescape = /\\\\(?:[\"\\\\\\/bfnrt]|u[0-9a-fA-F]{4})/g;\nvar rvalidtokens = /\"[^\"\\\\\\n\\r]*\"|true|false|null|-?\\d+(?:\\.\\d*)?(?:[eE][+\\-]?\\d+)?/g;\nvar rvalidbraces = /(?:^|:|,)(?:\\s*\\[)+/g;\nvar rtrimLeft = /^\\s+/;\nvar rtrimRight = /\\s+$/;\n\nmodule.exports = function parsejson(data) {\n if ('string' != typeof data || !data) {\n return null;\n }\n\n data = data.replace(rtrimLeft, '').replace(rtrimRight, '');\n\n // Attempt to parse using the native JSON parser first\n if (global.JSON && JSON.parse) {\n return JSON.parse(data);\n }\n\n if (rvalidchars.test(data.replace(rvalidescape, '@')\n .replace(rvalidtokens, ']')\n .replace(rvalidbraces, ''))) {\n return (new Function('return ' + data))();\n }\n};\n/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))\n\n/*****************\n ** WEBPACK FOOTER\n ** (webpack)-dev-server/~/socket.io-client/~/engine.io-client/~/parsejson/index.js\n ** module id = 45\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///(webpack)-dev-server/~/socket.io-client/~/engine.io-client/~/parsejson/index.js?");
|
||
|
||
/***/ },
|
||
/* 46 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("\n/**\n * Module dependencies.\n */\n\nvar parser = __webpack_require__(7);\nvar Emitter = __webpack_require__(8);\nvar toArray = __webpack_require__(47);\nvar on = __webpack_require__(48);\nvar bind = __webpack_require__(49);\nvar debug = __webpack_require__(4)('socket.io-client:socket');\nvar hasBin = __webpack_require__(50);\n\n/**\n * Module exports.\n */\n\nmodule.exports = exports = Socket;\n\n/**\n * Internal events (blacklisted).\n * These events can't be emitted by the user.\n *\n * @api private\n */\n\nvar events = {\n connect: 1,\n connect_error: 1,\n connect_timeout: 1,\n disconnect: 1,\n error: 1,\n reconnect: 1,\n reconnect_attempt: 1,\n reconnect_failed: 1,\n reconnect_error: 1,\n reconnecting: 1\n};\n\n/**\n * Shortcut to `Emitter#emit`.\n */\n\nvar emit = Emitter.prototype.emit;\n\n/**\n * `Socket` constructor.\n *\n * @api public\n */\n\nfunction Socket(io, nsp){\n this.io = io;\n this.nsp = nsp;\n this.json = this; // compat\n this.ids = 0;\n this.acks = {};\n if (this.io.autoConnect) this.open();\n this.receiveBuffer = [];\n this.sendBuffer = [];\n this.connected = false;\n this.disconnected = true;\n}\n\n/**\n * Mix in `Emitter`.\n */\n\nEmitter(Socket.prototype);\n\n/**\n * Subscribe to open, close and packet events\n *\n * @api private\n */\n\nSocket.prototype.subEvents = function() {\n if (this.subs) return;\n\n var io = this.io;\n this.subs = [\n on(io, 'open', bind(this, 'onopen')),\n on(io, 'packet', bind(this, 'onpacket')),\n on(io, 'close', bind(this, 'onclose'))\n ];\n};\n\n/**\n * \"Opens\" the socket.\n *\n * @api public\n */\n\nSocket.prototype.open =\nSocket.prototype.connect = function(){\n if (this.connected) return this;\n\n this.subEvents();\n this.io.open(); // ensure open\n if ('open' == this.io.readyState) this.onopen();\n return this;\n};\n\n/**\n * Sends a `message` event.\n *\n * @return {Socket} self\n * @api public\n */\n\nSocket.prototype.send = function(){\n var args = toArray(arguments);\n args.unshift('message');\n this.emit.apply(this, args);\n return this;\n};\n\n/**\n * Override `emit`.\n * If the event is in `events`, it's emitted normally.\n *\n * @param {String} event name\n * @return {Socket} self\n * @api public\n */\n\nSocket.prototype.emit = function(ev){\n if (events.hasOwnProperty(ev)) {\n emit.apply(this, arguments);\n return this;\n }\n\n var args = toArray(arguments);\n var parserType = parser.EVENT; // default\n if (hasBin(args)) { parserType = parser.BINARY_EVENT; } // binary\n var packet = { type: parserType, data: args };\n\n // event ack callback\n if ('function' == typeof args[args.length - 1]) {\n debug('emitting packet with ack id %d', this.ids);\n this.acks[this.ids] = args.pop();\n packet.id = this.ids++;\n }\n\n if (this.connected) {\n this.packet(packet);\n } else {\n this.sendBuffer.push(packet);\n }\n\n return this;\n};\n\n/**\n * Sends a packet.\n *\n * @param {Object} packet\n * @api private\n */\n\nSocket.prototype.packet = function(packet){\n packet.nsp = this.nsp;\n this.io.packet(packet);\n};\n\n/**\n * Called upon engine `open`.\n *\n * @api private\n */\n\nSocket.prototype.onopen = function(){\n debug('transport is open - connecting');\n\n // write connect packet if necessary\n if ('/' != this.nsp) {\n this.packet({ type: parser.CONNECT });\n }\n};\n\n/**\n * Called upon engine `close`.\n *\n * @param {String} reason\n * @api private\n */\n\nSocket.prototype.onclose = function(reason){\n debug('close (%s)', reason);\n this.connected = false;\n this.disconnected = true;\n delete this.id;\n this.emit('disconnect', reason);\n};\n\n/**\n * Called with socket packet.\n *\n * @param {Object} packet\n * @api private\n */\n\nSocket.prototype.onpacket = function(packet){\n if (packet.nsp != this.nsp) return;\n\n switch (packet.type) {\n case parser.CONNECT:\n this.onconnect();\n break;\n\n case parser.EVENT:\n this.onevent(packet);\n break;\n\n case parser.BINARY_EVENT:\n this.onevent(packet);\n break;\n\n case parser.ACK:\n this.onack(packet);\n break;\n\n case parser.BINARY_ACK:\n this.onack(packet);\n break;\n\n case parser.DISCONNECT:\n this.ondisconnect();\n break;\n\n case parser.ERROR:\n this.emit('error', packet.data);\n break;\n }\n};\n\n/**\n * Called upon a server event.\n *\n * @param {Object} packet\n * @api private\n */\n\nSocket.prototype.onevent = function(packet){\n var args = packet.data || [];\n debug('emitting event %j', args);\n\n if (null != packet.id) {\n debug('attaching ack callback to event');\n args.push(this.ack(packet.id));\n }\n\n if (this.connected) {\n emit.apply(this, args);\n } else {\n this.receiveBuffer.push(args);\n }\n};\n\n/**\n * Produces an ack callback to emit with an event.\n *\n * @api private\n */\n\nSocket.prototype.ack = function(id){\n var self = this;\n var sent = false;\n return function(){\n // prevent double callbacks\n if (sent) return;\n sent = true;\n var args = toArray(arguments);\n debug('sending ack %j', args);\n\n var type = hasBin(args) ? parser.BINARY_ACK : parser.ACK;\n self.packet({\n type: type,\n id: id,\n data: args\n });\n };\n};\n\n/**\n * Called upon a server acknowlegement.\n *\n * @param {Object} packet\n * @api private\n */\n\nSocket.prototype.onack = function(packet){\n debug('calling ack %s with %j', packet.id, packet.data);\n var fn = this.acks[packet.id];\n fn.apply(this, packet.data);\n delete this.acks[packet.id];\n};\n\n/**\n * Called upon server connect.\n *\n * @api private\n */\n\nSocket.prototype.onconnect = function(){\n this.connected = true;\n this.disconnected = false;\n this.emit('connect');\n this.emitBuffered();\n};\n\n/**\n * Emit buffered events (received and emitted).\n *\n * @api private\n */\n\nSocket.prototype.emitBuffered = function(){\n var i;\n for (i = 0; i < this.receiveBuffer.length; i++) {\n emit.apply(this, this.receiveBuffer[i]);\n }\n this.receiveBuffer = [];\n\n for (i = 0; i < this.sendBuffer.length; i++) {\n this.packet(this.sendBuffer[i]);\n }\n this.sendBuffer = [];\n};\n\n/**\n * Called upon server disconnect.\n *\n * @api private\n */\n\nSocket.prototype.ondisconnect = function(){\n debug('server disconnect (%s)', this.nsp);\n this.destroy();\n this.onclose('io server disconnect');\n};\n\n/**\n * Called upon forced client/server side disconnections,\n * this method ensures the manager stops tracking us and\n * that reconnections don't get triggered for this.\n *\n * @api private.\n */\n\nSocket.prototype.destroy = function(){\n if (this.subs) {\n // clean subscriptions to avoid reconnections\n for (var i = 0; i < this.subs.length; i++) {\n this.subs[i].destroy();\n }\n this.subs = null;\n }\n\n this.io.destroy(this);\n};\n\n/**\n * Disconnects the socket manually.\n *\n * @return {Socket} self\n * @api public\n */\n\nSocket.prototype.close =\nSocket.prototype.disconnect = function(){\n if (this.connected) {\n debug('performing disconnect (%s)', this.nsp);\n this.packet({ type: parser.DISCONNECT });\n }\n\n // remove socket from pool\n this.destroy();\n\n if (this.connected) {\n // fire events\n this.onclose('io client disconnect');\n }\n return this;\n};\n\n\n/*****************\n ** WEBPACK FOOTER\n ** (webpack)-dev-server/~/socket.io-client/lib/socket.js\n ** module id = 46\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///(webpack)-dev-server/~/socket.io-client/lib/socket.js?");
|
||
|
||
/***/ },
|
||
/* 47 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("module.exports = toArray\n\nfunction toArray(list, index) {\n var array = []\n\n index = index || 0\n\n for (var i = index || 0; i < list.length; i++) {\n array[i - index] = list[i]\n }\n\n return array\n}\n\n\n/*****************\n ** WEBPACK FOOTER\n ** (webpack)-dev-server/~/socket.io-client/~/to-array/index.js\n ** module id = 47\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///(webpack)-dev-server/~/socket.io-client/~/to-array/index.js?");
|
||
|
||
/***/ },
|
||
/* 48 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("\n/**\n * Module exports.\n */\n\nmodule.exports = on;\n\n/**\n * Helper for subscriptions.\n *\n * @param {Object|EventEmitter} obj with `Emitter` mixin or `EventEmitter`\n * @param {String} event name\n * @param {Function} callback\n * @api public\n */\n\nfunction on(obj, ev, fn) {\n obj.on(ev, fn);\n return {\n destroy: function(){\n obj.removeListener(ev, fn);\n }\n };\n}\n\n\n/*****************\n ** WEBPACK FOOTER\n ** (webpack)-dev-server/~/socket.io-client/lib/on.js\n ** module id = 48\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///(webpack)-dev-server/~/socket.io-client/lib/on.js?");
|
||
|
||
/***/ },
|
||
/* 49 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("/**\n * Slice reference.\n */\n\nvar slice = [].slice;\n\n/**\n * Bind `obj` to `fn`.\n *\n * @param {Object} obj\n * @param {Function|String} fn or string\n * @return {Function}\n * @api public\n */\n\nmodule.exports = function(obj, fn){\n if ('string' == typeof fn) fn = obj[fn];\n if ('function' != typeof fn) throw new Error('bind() requires a function');\n var args = slice.call(arguments, 2);\n return function(){\n return fn.apply(obj, args.concat(slice.call(arguments)));\n }\n};\n\n\n/*****************\n ** WEBPACK FOOTER\n ** (webpack)-dev-server/~/socket.io-client/~/component-bind/index.js\n ** module id = 49\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///(webpack)-dev-server/~/socket.io-client/~/component-bind/index.js?");
|
||
|
||
/***/ },
|
||
/* 50 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/* WEBPACK VAR INJECTION */(function(global) {\n/*\n * Module requirements.\n */\n\nvar isArray = __webpack_require__(51);\n\n/**\n * Module exports.\n */\n\nmodule.exports = hasBinary;\n\n/**\n * Checks for binary data.\n *\n * Right now only Buffer and ArrayBuffer are supported..\n *\n * @param {Object} anything\n * @api public\n */\n\nfunction hasBinary(data) {\n\n function _hasBinary(obj) {\n if (!obj) return false;\n\n if ( (global.Buffer && global.Buffer.isBuffer(obj)) ||\n (global.ArrayBuffer && obj instanceof ArrayBuffer) ||\n (global.Blob && obj instanceof Blob) ||\n (global.File && obj instanceof File)\n ) {\n return true;\n }\n\n if (isArray(obj)) {\n for (var i = 0; i < obj.length; i++) {\n if (_hasBinary(obj[i])) {\n return true;\n }\n }\n } else if (obj && 'object' == typeof obj) {\n if (obj.toJSON) {\n obj = obj.toJSON();\n }\n\n for (var key in obj) {\n if (Object.prototype.hasOwnProperty.call(obj, key) && _hasBinary(obj[key])) {\n return true;\n }\n }\n }\n\n return false;\n }\n\n return _hasBinary(data);\n}\n\n/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))\n\n/*****************\n ** WEBPACK FOOTER\n ** (webpack)-dev-server/~/socket.io-client/~/has-binary/index.js\n ** module id = 50\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///(webpack)-dev-server/~/socket.io-client/~/has-binary/index.js?");
|
||
|
||
/***/ },
|
||
/* 51 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("module.exports = Array.isArray || function (arr) {\n return Object.prototype.toString.call(arr) == '[object Array]';\n};\n\n\n/*****************\n ** WEBPACK FOOTER\n ** (webpack)-dev-server/~/socket.io-client/~/has-binary/~/isarray/index.js\n ** module id = 51\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///(webpack)-dev-server/~/socket.io-client/~/has-binary/~/isarray/index.js?");
|
||
|
||
/***/ },
|
||
/* 52 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("\n/**\n * HOP ref.\n */\n\nvar has = Object.prototype.hasOwnProperty;\n\n/**\n * Return own keys in `obj`.\n *\n * @param {Object} obj\n * @return {Array}\n * @api public\n */\n\nexports.keys = Object.keys || function(obj){\n var keys = [];\n for (var key in obj) {\n if (has.call(obj, key)) {\n keys.push(key);\n }\n }\n return keys;\n};\n\n/**\n * Return own values in `obj`.\n *\n * @param {Object} obj\n * @return {Array}\n * @api public\n */\n\nexports.values = function(obj){\n var vals = [];\n for (var key in obj) {\n if (has.call(obj, key)) {\n vals.push(obj[key]);\n }\n }\n return vals;\n};\n\n/**\n * Merge `b` into `a`.\n *\n * @param {Object} a\n * @param {Object} b\n * @return {Object} a\n * @api public\n */\n\nexports.merge = function(a, b){\n for (var key in b) {\n if (has.call(b, key)) {\n a[key] = b[key];\n }\n }\n return a;\n};\n\n/**\n * Return length of `obj`.\n *\n * @param {Object} obj\n * @return {Number}\n * @api public\n */\n\nexports.length = function(obj){\n return exports.keys(obj).length;\n};\n\n/**\n * Check if `obj` is empty.\n *\n * @param {Object} obj\n * @return {Boolean}\n * @api public\n */\n\nexports.isEmpty = function(obj){\n return 0 == exports.length(obj);\n};\n\n/*****************\n ** WEBPACK FOOTER\n ** (webpack)-dev-server/~/socket.io-client/~/object-component/index.js\n ** module id = 52\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///(webpack)-dev-server/~/socket.io-client/~/object-component/index.js?");
|
||
|
||
/***/ },
|
||
/* 53 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("\n/**\n * Expose `Backoff`.\n */\n\nmodule.exports = Backoff;\n\n/**\n * Initialize backoff timer with `opts`.\n *\n * - `min` initial timeout in milliseconds [100]\n * - `max` max timeout [10000]\n * - `jitter` [0]\n * - `factor` [2]\n *\n * @param {Object} opts\n * @api public\n */\n\nfunction Backoff(opts) {\n opts = opts || {};\n this.ms = opts.min || 100;\n this.max = opts.max || 10000;\n this.factor = opts.factor || 2;\n this.jitter = opts.jitter > 0 && opts.jitter <= 1 ? opts.jitter : 0;\n this.attempts = 0;\n}\n\n/**\n * Return the backoff duration.\n *\n * @return {Number}\n * @api public\n */\n\nBackoff.prototype.duration = function(){\n var ms = this.ms * Math.pow(this.factor, this.attempts++);\n if (this.jitter) {\n var rand = Math.random();\n var deviation = Math.floor(rand * this.jitter * ms);\n ms = (Math.floor(rand * 10) & 1) == 0 ? ms - deviation : ms + deviation;\n }\n return Math.min(ms, this.max) | 0;\n};\n\n/**\n * Reset the number of attempts.\n *\n * @api public\n */\n\nBackoff.prototype.reset = function(){\n this.attempts = 0;\n};\n\n/**\n * Set the minimum duration\n *\n * @api public\n */\n\nBackoff.prototype.setMin = function(min){\n this.ms = min;\n};\n\n/**\n * Set the maximum duration\n *\n * @api public\n */\n\nBackoff.prototype.setMax = function(max){\n this.max = max;\n};\n\n/**\n * Set the jitter\n *\n * @api public\n */\n\nBackoff.prototype.setJitter = function(jitter){\n this.jitter = jitter;\n};\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** (webpack)-dev-server/~/socket.io-client/~/backo2/index.js\n ** module id = 53\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///(webpack)-dev-server/~/socket.io-client/~/backo2/index.js?");
|
||
|
||
/***/ },
|
||
/* 54 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("'use strict';\nvar ansiRegex = __webpack_require__(55)();\n\nmodule.exports = function (str) {\n\treturn typeof str === 'string' ? str.replace(ansiRegex, '') : str;\n};\n\n\n/*****************\n ** WEBPACK FOOTER\n ** (webpack)-dev-server/~/strip-ansi/index.js\n ** module id = 54\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///(webpack)-dev-server/~/strip-ansi/index.js?");
|
||
|
||
/***/ },
|
||
/* 55 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("'use strict';\nmodule.exports = function () {\n\treturn /(?:(?:\\u001b\\[)|\\u009b)(?:(?:[0-9]{1,3})?(?:(?:;[0-9]{0,3})*)?[A-M|f-m])|\\u001b[A-M]/g;\n};\n\n\n/*****************\n ** WEBPACK FOOTER\n ** (webpack)-dev-server/~/strip-ansi/~/ansi-regex/index.js\n ** module id = 55\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///(webpack)-dev-server/~/strip-ansi/~/ansi-regex/index.js?");
|
||
|
||
/***/ },
|
||
/* 56 */
|
||
/***/ 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\n/*globals window __webpack_hash__ */\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__(57)(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 = 56\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///(webpack)/hot/only-dev-server.js?");
|
||
|
||
/***/ },
|
||
/* 57 */
|
||
/***/ function(module, exports) {
|
||
|
||
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 = 57\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///(webpack)/hot/log-apply-result.js?");
|
||
|
||
/***/ },
|
||
/* 58 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/* WEBPACK VAR INJECTION */(function(module) {/* REACT HOT LOADER */ if (true) { (function () { var ReactHotAPI = __webpack_require__(217), RootInstanceProvider = __webpack_require__(59), ReactMount = __webpack_require__(61), React = __webpack_require__(115); module.makeHot = module.hot.data ? module.hot.data.makeHot : ReactHotAPI(function () { return RootInstanceProvider.getRootInstances(ReactMount); }, React); })(); } (function () {\n\n'use strict';\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nvar _react = __webpack_require__(115);\n\nvar _react2 = _interopRequireDefault(_react);\n\nvar _containersApp = __webpack_require__(225);\n\nvar _containersApp2 = _interopRequireDefault(_containersApp);\n\n__webpack_require__(296);\n\n_react2['default'].render(_react2['default'].createElement(_containersApp2['default'], null), document.getElementById('root'));\n\n/* REACT HOT LOADER */ }).call(this); if (true) { (function () { module.hot.dispose(function (data) { data.makeHot = module.makeHot; }); if (module.exports && module.makeHot) { var makeExportsHot = __webpack_require__(254), foundReactClasses = false; if (makeExportsHot(module, __webpack_require__(115))) { foundReactClasses = true; } var shouldAcceptModule = true && foundReactClasses; if (shouldAcceptModule) { module.hot.accept(function (err) { if (err) { console.error(\"Cannot not apply hot update to \" + \"index.js\" + \": \" + err.message); } }); } } })(); }\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(34)(module)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./index.js\n ** module id = 58\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./index.js?");
|
||
|
||
/***/ },
|
||
/* 59 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("'use strict';\n\nvar getRootInstancesFromReactMount = __webpack_require__(60);\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 = 59\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react-hot-loader/RootInstanceProvider.js?");
|
||
|
||
/***/ },
|
||
/* 60 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("'use strict';\n\nfunction getRootInstancesFromReactMount(ReactMount) {\n return ReactMount._instancesByReactRootID || ReactMount._instancesByContainerID || [];\n}\n\nmodule.exports = getRootInstancesFromReactMount;\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react-hot-loader/getRootInstancesFromReactMount.js\n ** module id = 60\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react-hot-loader/getRootInstancesFromReactMount.js?");
|
||
|
||
/***/ },
|
||
/* 61 */
|
||
/***/ 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__(63);\nvar ReactBrowserEventEmitter = __webpack_require__(65);\nvar ReactCurrentOwner = __webpack_require__(78);\nvar ReactElement = __webpack_require__(79);\nvar ReactElementValidator = __webpack_require__(84);\nvar ReactEmptyComponent = __webpack_require__(90);\nvar ReactInstanceHandles = __webpack_require__(92);\nvar ReactInstanceMap = __webpack_require__(91);\nvar ReactMarkupChecksum = __webpack_require__(94);\nvar ReactPerf = __webpack_require__(96);\nvar ReactReconciler = __webpack_require__(97);\nvar ReactUpdateQueue = __webpack_require__(100);\nvar ReactUpdates = __webpack_require__(101);\n\nvar emptyObject = __webpack_require__(81);\nvar containsNode = __webpack_require__(106);\nvar getReactRootElementInContainer = __webpack_require__(109);\nvar instantiateReactComponent = __webpack_require__(110);\nvar invariant = __webpack_require__(64);\nvar setInnerHTML = __webpack_require__(114);\nvar shouldUpdateReactComponent = __webpack_require__(113);\nvar warning = __webpack_require__(82);\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 !== undefined ?\n ' This may be caused by unintentionally loading two independent ' +\n 'copies of React.' :\n ''\n )\n ) : invariant(ReactElement.isValidElement(nextElement)));\n\n var prevComponent = instancesByReactRootID[getReactRootID(container)];\n\n if (prevComponent) {\n var prevElement = prevComponent._currentElement;\n if (shouldUpdateReactComponent(prevElement, nextElement)) {\n return ReactMount._updateRootComponent(\n prevComponent,\n nextElement,\n container,\n callback\n ).getPublicInstance();\n } else {\n ReactMount.unmountComponentAtNode(container);\n }\n }\n\n var reactRootElement = getReactRootElementInContainer(container);\n var containerHasReactMarkup =\n reactRootElement && ReactMount.isRenderedByReact(reactRootElement);\n\n if (\"production\" !== process.env.NODE_ENV) {\n if (!containerHasReactMarkup || reactRootElement.nextSibling) {\n var rootElementSibling = reactRootElement;\n while (rootElementSibling) {\n if (ReactMount.isRenderedByReact(rootElementSibling)) {\n (\"production\" !== process.env.NODE_ENV ? warning(\n false,\n 'render(): Target node has markup rendered by React, but there ' +\n 'are unrelated nodes as well. This is most commonly caused by ' +\n 'white-space inserted around server-rendered markup.'\n ) : null);\n break;\n }\n\n rootElementSibling = rootElementSibling.nextSibling;\n }\n }\n }\n\n var shouldReuseMarkup = containerHasReactMarkup && !prevComponent;\n\n var component = ReactMount._renderNewRootComponent(\n nextElement,\n container,\n shouldReuseMarkup\n ).getPublicInstance();\n if (callback) {\n callback.call(component);\n }\n return component;\n },\n\n /**\n * Constructs a component instance of `constructor` with `initialProps` and\n * renders it into the supplied `container`.\n *\n * @param {function} constructor React component constructor.\n * @param {?object} props Initial props of the component instance.\n * @param {DOMElement} container DOM element to render into.\n * @return {ReactComponent} Component instance rendered in `container`.\n */\n constructAndRenderComponent: function(constructor, props, container) {\n var element = ReactElement.createElement(constructor, props);\n return ReactMount.render(element, container);\n },\n\n /**\n * Constructs a component instance of `constructor` with `initialProps` and\n * renders it into a container node identified by supplied `id`.\n *\n * @param {function} componentConstructor React component constructor\n * @param {?object} props Initial props of the component instance.\n * @param {string} id ID of the DOM element to render into.\n * @return {ReactComponent} Component instance rendered in the container node.\n */\n constructAndRenderComponentByID: function(constructor, props, id) {\n var domNode = document.getElementById(id);\n (\"production\" !== process.env.NODE_ENV ? invariant(\n domNode,\n 'Tried to get element with id of \"%s\" but it is not present on the page.',\n id\n ) : invariant(domNode));\n return ReactMount.constructAndRenderComponent(constructor, props, domNode);\n },\n\n /**\n * Registers a container node into which React components will be rendered.\n * This also creates the \"reactRoot\" ID that will be assigned to the element\n * rendered within.\n *\n * @param {DOMElement} container DOM element to register as a container.\n * @return {string} The \"reactRoot\" ID of elements rendered within.\n */\n registerContainer: function(container) {\n var reactRootID = getReactRootID(container);\n if (reactRootID) {\n // If one exists, make sure it is a valid \"reactRoot\" ID.\n reactRootID = ReactInstanceHandles.getReactRootIDFromNodeID(reactRootID);\n }\n if (!reactRootID) {\n // No valid \"reactRoot\" ID found, create one.\n reactRootID = ReactInstanceHandles.createReactRootID();\n }\n containersByReactRootID[reactRootID] = container;\n return reactRootID;\n },\n\n /**\n * Unmounts and destroys the React component rendered in the `container`.\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 (\"production\" !== process.env.NODE_ENV ? warning(\n ReactCurrentOwner.current == null,\n 'unmountComponentAtNode(): Render methods should be a pure function of ' +\n 'props and state; triggering nested component updates from render is ' +\n 'not allowed. If necessary, trigger nested updates in ' +\n 'componentDidUpdate.'\n ) : null);\n\n (\"production\" !== process.env.NODE_ENV ? invariant(\n container && (\n (container.nodeType === ELEMENT_NODE_TYPE || container.nodeType === DOC_NODE_TYPE)\n ),\n 'unmountComponentAtNode(...): Target container is not a DOM element.'\n ) : invariant(container && (\n (container.nodeType === ELEMENT_NODE_TYPE || container.nodeType === DOC_NODE_TYPE)\n )));\n\n var reactRootID = getReactRootID(container);\n var component = instancesByReactRootID[reactRootID];\n if (!component) {\n return false;\n }\n ReactMount.unmountComponentFromNode(component, container);\n delete instancesByReactRootID[reactRootID];\n delete containersByReactRootID[reactRootID];\n if (\"production\" !== process.env.NODE_ENV) {\n delete rootElementsByReactRootID[reactRootID];\n }\n return true;\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 */\n unmountComponentFromNode: function(instance, container) {\n ReactReconciler.unmountComponent(instance);\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 * Finds the container DOM element that contains React component to which the\n * supplied DOM `id` belongs.\n *\n * @param {string} id The ID of an element rendered by a React component.\n * @return {?DOMElement} DOM element that contains the `id`.\n */\n findReactContainerForID: function(id) {\n var reactRootID = ReactInstanceHandles.getReactRootIDFromNodeID(id);\n var container = containersByReactRootID[reactRootID];\n\n if (\"production\" !== process.env.NODE_ENV) {\n var rootElement = rootElementsByReactRootID[reactRootID];\n if (rootElement && rootElement.parentNode !== container) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n // Call internalGetID here because getID calls isValid which calls\n // findReactContainerForID (this function).\n internalGetID(rootElement) === reactRootID,\n 'ReactMount: Root element ID differed from reactRootID.'\n ) : invariant(// Call internalGetID here because getID calls isValid which calls\n // findReactContainerForID (this function).\n internalGetID(rootElement) === reactRootID));\n\n var containerChild = container.firstChild;\n if (containerChild &&\n reactRootID === internalGetID(containerChild)) {\n // If the container has a new child with the same ID as the old\n // root element, then rootElementsByReactRootID[reactRootID] is\n // just stale and needs to be updated. The case that deserves a\n // warning is when the container is empty.\n rootElementsByReactRootID[reactRootID] = containerChild;\n } else {\n (\"production\" !== process.env.NODE_ENV ? warning(\n false,\n 'ReactMount: Root element has been removed from its original ' +\n 'container. New container:', rootElement.parentNode\n ) : null);\n }\n }\n }\n\n return container;\n },\n\n /**\n * Finds an element rendered by React with the supplied ID.\n *\n * @param {string} id ID of a DOM node in the React component.\n * @return {DOMElement} Root DOM node of the React component.\n */\n findReactNodeByID: function(id) {\n var reactRoot = ReactMount.findReactContainerForID(id);\n return ReactMount.findComponentRoot(reactRoot, id);\n },\n\n /**\n * True if the supplied `node` is rendered by React.\n *\n * @param {*} node DOM Element to check.\n * @return {boolean} True if the DOM Element appears to be rendered by React.\n * @internal\n */\n isRenderedByReact: function(node) {\n if (node.nodeType !== 1) {\n // Not a DOMElement, therefore not a React component\n return false;\n }\n var id = ReactMount.getID(node);\n return id ? id.charAt(0) === SEPARATOR : false;\n },\n\n /**\n * Traverses up the ancestors of the supplied node to find a node that is a\n * DOM representation of a React component.\n *\n * @param {*} node\n * @return {?DOMEventTarget}\n * @internal\n */\n getFirstReactDOM: function(node) {\n var current = node;\n while (current && current.parentNode !== current) {\n if (ReactMount.isRenderedByReact(current)) {\n return current;\n }\n current = current.parentNode;\n }\n return null;\n },\n\n /**\n * Finds a node with the supplied `targetID` inside of the supplied\n * `ancestorNode`. Exploits the ID naming scheme to perform the search\n * quickly.\n *\n * @param {DOMEventTarget} ancestorNode Search from this root.\n * @pararm {string} targetID ID of the DOM representation of the component.\n * @return {DOMEventTarget} DOM node with the supplied `targetID`.\n * @internal\n */\n findComponentRoot: function(ancestorNode, targetID) {\n var firstChildren = findComponentRootReusableArray;\n var childIndex = 0;\n\n var deepestAncestor = findDeepestCachedAncestor(targetID) || ancestorNode;\n\n firstChildren[0] = deepestAncestor.firstChild;\n firstChildren.length = 1;\n\n while (childIndex < firstChildren.length) {\n var child = firstChildren[childIndex++];\n var targetChild;\n\n while (child) {\n var childID = ReactMount.getID(child);\n if (childID) {\n // Even if we find the node we're looking for, we finish looping\n // through its siblings to ensure they're cached so that we don't have\n // to revisit this node again. Otherwise, we make n^2 calls to getID\n // when visiting the many children of a single node in order.\n\n if (targetID === childID) {\n targetChild = child;\n } else if (ReactInstanceHandles.isAncestorIDOf(childID, targetID)) {\n // If we find a child whose ID is an ancestor of the given ID,\n // then we can be sure that we only want to search the subtree\n // rooted at this child, so we can throw out the rest of the\n // search state.\n firstChildren.length = childIndex = 0;\n firstChildren.push(child.firstChild);\n }\n\n } else {\n // If this child had no ID, then there's a chance that it was\n // injected automatically by the browser, as when a `<table>`\n // element sprouts an extra `<tbody>` child as a side effect of\n // `.innerHTML` parsing. Optimistically continue down this\n // branch, but not before examining the other siblings.\n firstChildren.push(child.firstChild);\n }\n\n child = child.nextSibling;\n }\n\n if (targetChild) {\n // Emptying firstChildren/findComponentRootReusableArray is\n // not necessary for correctness, but it helps the GC reclaim\n // any nodes that were left at the end of the search.\n firstChildren.length = 0;\n\n return targetChild;\n }\n }\n\n firstChildren.length = 0;\n\n (\"production\" !== process.env.NODE_ENV ? invariant(\n false,\n 'findComponentRoot(..., %s): Unable to find element. This probably ' +\n 'means the DOM was unexpectedly mutated (e.g., by the browser), ' +\n 'usually due to forgetting a <tbody> when using tables, nesting tags ' +\n 'like <form>, <p>, or <a>, or using non-SVG elements in an <svg> ' +\n 'parent. ' +\n 'Try inspecting the child nodes of the element with React ID `%s`.',\n targetID,\n ReactMount.getID(ancestorNode)\n ) : invariant(false));\n },\n\n _mountImageIntoNode: function(markup, container, shouldReuseMarkup) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n container && (\n (container.nodeType === ELEMENT_NODE_TYPE || container.nodeType === DOC_NODE_TYPE)\n ),\n 'mountComponentIntoNode(...): Target container is not valid.'\n ) : invariant(container && (\n (container.nodeType === ELEMENT_NODE_TYPE || container.nodeType === DOC_NODE_TYPE)\n )));\n\n if (shouldReuseMarkup) {\n var rootElement = getReactRootElementInContainer(container);\n if (ReactMarkupChecksum.canReuseMarkup(markup, rootElement)) {\n return;\n } else {\n var checksum = rootElement.getAttribute(\n ReactMarkupChecksum.CHECKSUM_ATTR_NAME\n );\n rootElement.removeAttribute(ReactMarkupChecksum.CHECKSUM_ATTR_NAME);\n\n var rootMarkup = rootElement.outerHTML;\n rootElement.setAttribute(\n ReactMarkupChecksum.CHECKSUM_ATTR_NAME,\n checksum\n );\n\n var diffIndex = firstDifferenceIndex(markup, rootMarkup);\n var difference = ' (client) ' +\n markup.substring(diffIndex - 20, diffIndex + 20) +\n '\\n (server) ' + rootMarkup.substring(diffIndex - 20, diffIndex + 20);\n\n (\"production\" !== process.env.NODE_ENV ? invariant(\n container.nodeType !== DOC_NODE_TYPE,\n 'You\\'re trying to render a component to the document using ' +\n 'server rendering but the checksum was invalid. This usually ' +\n 'means you rendered a different component type or props on ' +\n 'the client from the one on the server, or your render() ' +\n 'methods are impure. React cannot handle this case due to ' +\n 'cross-browser quirks by rendering at the document root. You ' +\n 'should look for environment dependent code in your components ' +\n 'and ensure the props are the same client and server side:\\n%s',\n difference\n ) : invariant(container.nodeType !== DOC_NODE_TYPE));\n\n if (\"production\" !== process.env.NODE_ENV) {\n (\"production\" !== process.env.NODE_ENV ? warning(\n false,\n 'React attempted to reuse markup in a container but the ' +\n 'checksum was invalid. This generally means that you are ' +\n 'using server rendering and the markup generated on the ' +\n 'server was not what the client was expecting. React injected ' +\n 'new markup to compensate which works but you have lost many ' +\n 'of the benefits of server rendering. Instead, figure out ' +\n 'why the markup being generated is different on the client ' +\n 'or server:\\n%s',\n difference\n ) : null);\n }\n }\n }\n\n (\"production\" !== process.env.NODE_ENV ? invariant(\n container.nodeType !== DOC_NODE_TYPE,\n 'You\\'re trying to render a component to the document but ' +\n 'you didn\\'t use server rendering. We can\\'t do this ' +\n 'without using server rendering due to cross-browser quirks. ' +\n 'See React.renderToString() for server rendering.'\n ) : invariant(container.nodeType !== DOC_NODE_TYPE));\n\n setInnerHTML(container, markup);\n },\n\n /**\n * React ID utilities.\n */\n\n getReactRootID: getReactRootID,\n\n getID: getID,\n\n setID: setID,\n\n getNode: getNode,\n\n getNodeFromInstance: getNodeFromInstance,\n\n purgeID: purgeID\n};\n\nReactPerf.measureMethods(ReactMount, 'ReactMount', {\n _renderNewRootComponent: '_renderNewRootComponent',\n _mountImageIntoNode: '_mountImageIntoNode'\n});\n\nmodule.exports = ReactMount;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactMount.js\n ** module id = 61\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ReactMount.js?");
|
||
|
||
/***/ },
|
||
/* 62 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("// shim for using process in browser\n\nvar process = module.exports = {};\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n draining = false;\n if (currentQueue.length) {\n queue = currentQueue.concat(queue);\n } else {\n queueIndex = -1;\n }\n if (queue.length) {\n drainQueue();\n }\n}\n\nfunction drainQueue() {\n if (draining) {\n return;\n }\n var timeout = setTimeout(cleanUpNextTick);\n draining = true;\n\n var len = queue.length;\n while(len) {\n currentQueue = queue;\n queue = [];\n while (++queueIndex < len) {\n currentQueue[queueIndex].run();\n }\n queueIndex = -1;\n len = queue.length;\n }\n currentQueue = null;\n draining = false;\n clearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n var args = new Array(arguments.length - 1);\n if (arguments.length > 1) {\n for (var i = 1; i < arguments.length; i++) {\n args[i - 1] = arguments[i];\n }\n }\n queue.push(new Item(fun, args));\n if (queue.length === 1 && !draining) {\n setTimeout(drainQueue, 0);\n }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n this.fun = fun;\n this.array = array;\n}\nItem.prototype.run = function () {\n this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\n\nprocess.binding = function (name) {\n throw new Error('process.binding is not supported');\n};\n\n// TODO(shtylman)\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/node-libs-browser/~/process/browser.js\n ** module id = 62\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/node-libs-browser/~/process/browser.js?");
|
||
|
||
/***/ },
|
||
/* 63 */
|
||
/***/ 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 DOMProperty\n * @typechecks static-only\n */\n\n/*jslint bitwise: true */\n\n'use strict';\n\nvar invariant = __webpack_require__(64);\n\nfunction checkMask(value, bitmask) {\n return (value & bitmask) === bitmask;\n}\n\nvar DOMPropertyInjection = {\n /**\n * Mapping from normalized, camelcased property names to a configuration that\n * specifies how the associated DOM property should be accessed or rendered.\n */\n MUST_USE_ATTRIBUTE: 0x1,\n MUST_USE_PROPERTY: 0x2,\n HAS_SIDE_EFFECTS: 0x4,\n HAS_BOOLEAN_VALUE: 0x8,\n HAS_NUMERIC_VALUE: 0x10,\n HAS_POSITIVE_NUMERIC_VALUE: 0x20 | 0x10,\n HAS_OVERLOADED_BOOLEAN_VALUE: 0x40,\n\n /**\n * Inject some specialized knowledge about the DOM. This takes a config object\n * with the following properties:\n *\n * isCustomAttribute: function that given an attribute name will return true\n * if it can be inserted into the DOM verbatim. Useful for data-* or aria-*\n * attributes where it's impossible to enumerate all of the possible\n * attribute names,\n *\n * Properties: object mapping DOM property name to one of the\n * DOMPropertyInjection constants or null. If your attribute isn't in here,\n * it won't get written to the DOM.\n *\n * DOMAttributeNames: object mapping React attribute name to the DOM\n * attribute name. Attribute names not specified use the **lowercase**\n * normalized name.\n *\n * DOMPropertyNames: similar to DOMAttributeNames but for DOM properties.\n * Property names not specified use the normalized name.\n *\n * DOMMutationMethods: Properties that require special mutation methods. If\n * `value` is undefined, the mutation method should unset the property.\n *\n * @param {object} domPropertyConfig the config as described above.\n */\n injectDOMPropertyConfig: function(domPropertyConfig) {\n var Properties = domPropertyConfig.Properties || {};\n var DOMAttributeNames = domPropertyConfig.DOMAttributeNames || {};\n var DOMPropertyNames = domPropertyConfig.DOMPropertyNames || {};\n var DOMMutationMethods = domPropertyConfig.DOMMutationMethods || {};\n\n if (domPropertyConfig.isCustomAttribute) {\n DOMProperty._isCustomAttributeFunctions.push(\n domPropertyConfig.isCustomAttribute\n );\n }\n\n for (var propName in Properties) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n !DOMProperty.isStandardName.hasOwnProperty(propName),\n 'injectDOMPropertyConfig(...): You\\'re trying to inject DOM property ' +\n '\\'%s\\' which has already been injected. You may be accidentally ' +\n 'injecting the same DOM property config twice, or you may be ' +\n 'injecting two configs that have conflicting property names.',\n propName\n ) : invariant(!DOMProperty.isStandardName.hasOwnProperty(propName)));\n\n DOMProperty.isStandardName[propName] = true;\n\n var lowerCased = propName.toLowerCase();\n DOMProperty.getPossibleStandardName[lowerCased] = propName;\n\n if (DOMAttributeNames.hasOwnProperty(propName)) {\n var attributeName = DOMAttributeNames[propName];\n DOMProperty.getPossibleStandardName[attributeName] = propName;\n DOMProperty.getAttributeName[propName] = attributeName;\n } else {\n DOMProperty.getAttributeName[propName] = lowerCased;\n }\n\n DOMProperty.getPropertyName[propName] =\n DOMPropertyNames.hasOwnProperty(propName) ?\n DOMPropertyNames[propName] :\n propName;\n\n if (DOMMutationMethods.hasOwnProperty(propName)) {\n DOMProperty.getMutationMethod[propName] = DOMMutationMethods[propName];\n } else {\n DOMProperty.getMutationMethod[propName] = null;\n }\n\n var propConfig = Properties[propName];\n DOMProperty.mustUseAttribute[propName] =\n checkMask(propConfig, DOMPropertyInjection.MUST_USE_ATTRIBUTE);\n DOMProperty.mustUseProperty[propName] =\n checkMask(propConfig, DOMPropertyInjection.MUST_USE_PROPERTY);\n DOMProperty.hasSideEffects[propName] =\n checkMask(propConfig, DOMPropertyInjection.HAS_SIDE_EFFECTS);\n DOMProperty.hasBooleanValue[propName] =\n checkMask(propConfig, DOMPropertyInjection.HAS_BOOLEAN_VALUE);\n DOMProperty.hasNumericValue[propName] =\n checkMask(propConfig, DOMPropertyInjection.HAS_NUMERIC_VALUE);\n DOMProperty.hasPositiveNumericValue[propName] =\n checkMask(propConfig, DOMPropertyInjection.HAS_POSITIVE_NUMERIC_VALUE);\n DOMProperty.hasOverloadedBooleanValue[propName] =\n checkMask(propConfig, DOMPropertyInjection.HAS_OVERLOADED_BOOLEAN_VALUE);\n\n (\"production\" !== process.env.NODE_ENV ? invariant(\n !DOMProperty.mustUseAttribute[propName] ||\n !DOMProperty.mustUseProperty[propName],\n 'DOMProperty: Cannot require using both attribute and property: %s',\n propName\n ) : invariant(!DOMProperty.mustUseAttribute[propName] ||\n !DOMProperty.mustUseProperty[propName]));\n (\"production\" !== process.env.NODE_ENV ? invariant(\n DOMProperty.mustUseProperty[propName] ||\n !DOMProperty.hasSideEffects[propName],\n 'DOMProperty: Properties that have side effects must use property: %s',\n propName\n ) : invariant(DOMProperty.mustUseProperty[propName] ||\n !DOMProperty.hasSideEffects[propName]));\n (\"production\" !== process.env.NODE_ENV ? invariant(\n !!DOMProperty.hasBooleanValue[propName] +\n !!DOMProperty.hasNumericValue[propName] +\n !!DOMProperty.hasOverloadedBooleanValue[propName] <= 1,\n 'DOMProperty: Value can be one of boolean, overloaded boolean, or ' +\n 'numeric value, but not a combination: %s',\n propName\n ) : invariant(!!DOMProperty.hasBooleanValue[propName] +\n !!DOMProperty.hasNumericValue[propName] +\n !!DOMProperty.hasOverloadedBooleanValue[propName] <= 1));\n }\n }\n};\nvar defaultValueCache = {};\n\n/**\n * DOMProperty exports lookup objects that can be used like functions:\n *\n * > DOMProperty.isValid['id']\n * true\n * > DOMProperty.isValid['foobar']\n * undefined\n *\n * Although this may be confusing, it performs better in general.\n *\n * @see http://jsperf.com/key-exists\n * @see http://jsperf.com/key-missing\n */\nvar DOMProperty = {\n\n ID_ATTRIBUTE_NAME: 'data-reactid',\n\n /**\n * Checks whether a property name is a standard property.\n * @type {Object}\n */\n isStandardName: {},\n\n /**\n * Mapping from lowercase property names to the properly cased version, used\n * to warn in the case of missing properties.\n * @type {Object}\n */\n getPossibleStandardName: {},\n\n /**\n * Mapping from normalized names to attribute names that differ. Attribute\n * names are used when rendering markup or with `*Attribute()`.\n * @type {Object}\n */\n getAttributeName: {},\n\n /**\n * Mapping from normalized names to properties on DOM node instances.\n * (This includes properties that mutate due to external factors.)\n * @type {Object}\n */\n getPropertyName: {},\n\n /**\n * Mapping from normalized names to mutation methods. This will only exist if\n * mutation cannot be set simply by the property or `setAttribute()`.\n * @type {Object}\n */\n getMutationMethod: {},\n\n /**\n * Whether the property must be accessed and mutated as an object property.\n * @type {Object}\n */\n mustUseAttribute: {},\n\n /**\n * Whether the property must be accessed and mutated using `*Attribute()`.\n * (This includes anything that fails `<propName> in <element>`.)\n * @type {Object}\n */\n mustUseProperty: {},\n\n /**\n * Whether or not setting a value causes side effects such as triggering\n * resources to be loaded or text selection changes. We must ensure that\n * the value is only set if it has changed.\n * @type {Object}\n */\n hasSideEffects: {},\n\n /**\n * Whether the property should be removed when set to a falsey value.\n * @type {Object}\n */\n hasBooleanValue: {},\n\n /**\n * Whether the property must be numeric or parse as a\n * numeric and should be removed when set to a falsey value.\n * @type {Object}\n */\n hasNumericValue: {},\n\n /**\n * Whether the property must be positive numeric or parse as a positive\n * numeric and should be removed when set to a falsey value.\n * @type {Object}\n */\n hasPositiveNumericValue: {},\n\n /**\n * Whether the property can be used as a flag as well as with a value. Removed\n * when strictly equal to false; present without a value when strictly equal\n * to true; present with a value otherwise.\n * @type {Object}\n */\n hasOverloadedBooleanValue: {},\n\n /**\n * All of the isCustomAttribute() functions that have been injected.\n */\n _isCustomAttributeFunctions: [],\n\n /**\n * Checks whether a property name is a custom attribute.\n * @method\n */\n isCustomAttribute: function(attributeName) {\n for (var i = 0; i < DOMProperty._isCustomAttributeFunctions.length; i++) {\n var isCustomAttributeFn = DOMProperty._isCustomAttributeFunctions[i];\n if (isCustomAttributeFn(attributeName)) {\n return true;\n }\n }\n return false;\n },\n\n /**\n * Returns the default property value for a DOM property (i.e., not an\n * attribute). Most default values are '' or false, but not all. Worse yet,\n * some (in particular, `type`) vary depending on the type of element.\n *\n * TODO: Is it better to grab all the possible properties when creating an\n * element to avoid having to create the same element twice?\n */\n getDefaultValueForProperty: function(nodeName, prop) {\n var nodeDefaults = defaultValueCache[nodeName];\n var testElement;\n if (!nodeDefaults) {\n defaultValueCache[nodeName] = nodeDefaults = {};\n }\n if (!(prop in nodeDefaults)) {\n testElement = document.createElement(nodeName);\n nodeDefaults[prop] = testElement[prop];\n }\n return nodeDefaults[prop];\n },\n\n injection: DOMPropertyInjection\n};\n\nmodule.exports = DOMProperty;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/DOMProperty.js\n ** module id = 63\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/DOMProperty.js?");
|
||
|
||
/***/ },
|
||
/* 64 */
|
||
/***/ 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 invariant\n */\n\n\"use strict\";\n\n/**\n * Use invariant() to assert state which your program assumes to be true.\n *\n * Provide sprintf-style format (only %s is supported) and arguments\n * to provide information about what broke and what you were\n * expecting.\n *\n * The invariant message will be stripped in production, but the invariant\n * will remain to ensure logic does not differ in production.\n */\n\nvar invariant = function(condition, format, a, b, c, d, e, f) {\n if (\"production\" !== process.env.NODE_ENV) {\n if (format === undefined) {\n throw new Error('invariant requires an error message argument');\n }\n }\n\n if (!condition) {\n var error;\n if (format === undefined) {\n error = new Error(\n 'Minified exception occurred; use the non-minified dev environment ' +\n 'for the full error message and additional helpful warnings.'\n );\n } else {\n var args = [a, b, c, d, e, f];\n var argIndex = 0;\n error = new Error(\n 'Invariant Violation: ' +\n format.replace(/%s/g, function() { return args[argIndex++]; })\n );\n }\n\n error.framesToPop = 1; // we don't care about invariant's own frame\n throw error;\n }\n};\n\nmodule.exports = invariant;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/invariant.js\n ** module id = 64\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/invariant.js?");
|
||
|
||
/***/ },
|
||
/* 65 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\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 ReactBrowserEventEmitter\n * @typechecks static-only\n */\n\n'use strict';\n\nvar EventConstants = __webpack_require__(66);\nvar EventPluginHub = __webpack_require__(68);\nvar EventPluginRegistry = __webpack_require__(69);\nvar ReactEventEmitterMixin = __webpack_require__(73);\nvar ViewportMetrics = __webpack_require__(74);\n\nvar assign = __webpack_require__(75);\nvar isEventSupported = __webpack_require__(76);\n\n/**\n * Summary of `ReactBrowserEventEmitter` event handling:\n *\n * - Top-level delegation is used to trap most native browser events. This\n * may only occur in the main thread and is the responsibility of\n * ReactEventListener, which is injected and can therefore support pluggable\n * event sources. This is the only work that occurs in the main thread.\n *\n * - We normalize and de-duplicate events to account for browser quirks. This\n * may be done in the worker thread.\n *\n * - Forward these native events (with the associated top-level type used to\n * trap it) to `EventPluginHub`, which in turn will ask plugins if they want\n * to extract any synthetic events.\n *\n * - The `EventPluginHub` will then process each event by annotating them with\n * \"dispatches\", a sequence of listeners and IDs that care about that event.\n *\n * - The `EventPluginHub` then dispatches the events.\n *\n * Overview of React and the event system:\n *\n * +------------+ .\n * | DOM | .\n * +------------+ .\n * | .\n * v .\n * +------------+ .\n * | ReactEvent | .\n * | Listener | .\n * +------------+ . +-----------+\n * | . +--------+|SimpleEvent|\n * | . | |Plugin |\n * +-----|------+ . v +-----------+\n * | | | . +--------------+ +------------+\n * | +-----------.--->|EventPluginHub| | Event |\n * | | . | | +-----------+ | Propagators|\n * | ReactEvent | . | | |TapEvent | |------------|\n * | Emitter | . | |<---+|Plugin | |other plugin|\n * | | . | | +-----------+ | utilities |\n * | +-----------.--->| | +------------+\n * | | | . +--------------+\n * +-----|------+ . ^ +-----------+\n * | . | |Enter/Leave|\n * + . +-------+|Plugin |\n * +-------------+ . +-----------+\n * | application | .\n * |-------------| .\n * | | .\n * | | .\n * +-------------+ .\n * .\n * React Core . General Purpose Event Plugin System\n */\n\nvar alreadyListeningTo = {};\nvar isMonitoringScrollValue = false;\nvar reactTopListenersCounter = 0;\n\n// For events like 'submit' which don't consistently bubble (which we trap at a\n// lower node than `document`), binding at `document` would cause duplicate\n// events so we don't include them here\nvar topEventMapping = {\n topBlur: 'blur',\n topChange: 'change',\n topClick: 'click',\n topCompositionEnd: 'compositionend',\n topCompositionStart: 'compositionstart',\n topCompositionUpdate: 'compositionupdate',\n topContextMenu: 'contextmenu',\n topCopy: 'copy',\n topCut: 'cut',\n topDoubleClick: 'dblclick',\n topDrag: 'drag',\n topDragEnd: 'dragend',\n topDragEnter: 'dragenter',\n topDragExit: 'dragexit',\n topDragLeave: 'dragleave',\n topDragOver: 'dragover',\n topDragStart: 'dragstart',\n topDrop: 'drop',\n topFocus: 'focus',\n topInput: 'input',\n topKeyDown: 'keydown',\n topKeyPress: 'keypress',\n topKeyUp: 'keyup',\n topMouseDown: 'mousedown',\n topMouseMove: 'mousemove',\n topMouseOut: 'mouseout',\n topMouseOver: 'mouseover',\n topMouseUp: 'mouseup',\n topPaste: 'paste',\n topScroll: 'scroll',\n topSelectionChange: 'selectionchange',\n topTextInput: 'textInput',\n topTouchCancel: 'touchcancel',\n topTouchEnd: 'touchend',\n topTouchMove: 'touchmove',\n topTouchStart: 'touchstart',\n topWheel: 'wheel'\n};\n\n/**\n * To ensure no conflicts with other potential React instances on the page\n */\nvar topListenersIDKey = '_reactListenersID' + String(Math.random()).slice(2);\n\nfunction getListeningForDocument(mountAt) {\n // In IE8, `mountAt` is a host object and doesn't have `hasOwnProperty`\n // directly.\n if (!Object.prototype.hasOwnProperty.call(mountAt, topListenersIDKey)) {\n mountAt[topListenersIDKey] = reactTopListenersCounter++;\n alreadyListeningTo[mountAt[topListenersIDKey]] = {};\n }\n return alreadyListeningTo[mountAt[topListenersIDKey]];\n}\n\n/**\n * `ReactBrowserEventEmitter` is used to attach top-level event listeners. For\n * example:\n *\n * ReactBrowserEventEmitter.putListener('myID', 'onClick', myFunction);\n *\n * This would allocate a \"registration\" of `('onClick', myFunction)` on 'myID'.\n *\n * @internal\n */\nvar ReactBrowserEventEmitter = assign({}, ReactEventEmitterMixin, {\n\n /**\n * Injectable event backend\n */\n ReactEventListener: null,\n\n injection: {\n /**\n * @param {object} ReactEventListener\n */\n injectReactEventListener: function(ReactEventListener) {\n ReactEventListener.setHandleTopLevel(\n ReactBrowserEventEmitter.handleTopLevel\n );\n ReactBrowserEventEmitter.ReactEventListener = ReactEventListener;\n }\n },\n\n /**\n * Sets whether or not any created callbacks should be enabled.\n *\n * @param {boolean} enabled True if callbacks should be enabled.\n */\n setEnabled: function(enabled) {\n if (ReactBrowserEventEmitter.ReactEventListener) {\n ReactBrowserEventEmitter.ReactEventListener.setEnabled(enabled);\n }\n },\n\n /**\n * @return {boolean} True if callbacks are enabled.\n */\n isEnabled: function() {\n return !!(\n (ReactBrowserEventEmitter.ReactEventListener && ReactBrowserEventEmitter.ReactEventListener.isEnabled())\n );\n },\n\n /**\n * We listen for bubbled touch events on the document object.\n *\n * Firefox v8.01 (and possibly others) exhibited strange behavior when\n * mounting `onmousemove` events at some node that was not the document\n * element. The symptoms were that if your mouse is not moving over something\n * contained within that mount point (for example on the background) the\n * top-level listeners for `onmousemove` won't be called. However, if you\n * register the `mousemove` on the document object, then it will of course\n * catch all `mousemove`s. This along with iOS quirks, justifies restricting\n * top-level listeners to the document object only, at least for these\n * movement types of events and possibly all events.\n *\n * @see http://www.quirksmode.org/blog/archives/2010/09/click_event_del.html\n *\n * Also, `keyup`/`keypress`/`keydown` do not bubble to the window on IE, but\n * they bubble to document.\n *\n * @param {string} registrationName Name of listener (e.g. `onClick`).\n * @param {object} contentDocumentHandle Document which owns the container\n */\n listenTo: function(registrationName, contentDocumentHandle) {\n var mountAt = contentDocumentHandle;\n var isListening = getListeningForDocument(mountAt);\n var dependencies = EventPluginRegistry.\n registrationNameDependencies[registrationName];\n\n var topLevelTypes = EventConstants.topLevelTypes;\n for (var i = 0, l = dependencies.length; i < l; i++) {\n var dependency = dependencies[i];\n if (!(\n (isListening.hasOwnProperty(dependency) && isListening[dependency])\n )) {\n if (dependency === topLevelTypes.topWheel) {\n if (isEventSupported('wheel')) {\n ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent(\n topLevelTypes.topWheel,\n 'wheel',\n mountAt\n );\n } else if (isEventSupported('mousewheel')) {\n ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent(\n topLevelTypes.topWheel,\n 'mousewheel',\n mountAt\n );\n } else {\n // Firefox needs to capture a different mouse scroll event.\n // @see http://www.quirksmode.org/dom/events/tests/scroll.html\n ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent(\n topLevelTypes.topWheel,\n 'DOMMouseScroll',\n mountAt\n );\n }\n } else if (dependency === topLevelTypes.topScroll) {\n\n if (isEventSupported('scroll', true)) {\n ReactBrowserEventEmitter.ReactEventListener.trapCapturedEvent(\n topLevelTypes.topScroll,\n 'scroll',\n mountAt\n );\n } else {\n ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent(\n topLevelTypes.topScroll,\n 'scroll',\n ReactBrowserEventEmitter.ReactEventListener.WINDOW_HANDLE\n );\n }\n } else if (dependency === topLevelTypes.topFocus ||\n dependency === topLevelTypes.topBlur) {\n\n if (isEventSupported('focus', true)) {\n ReactBrowserEventEmitter.ReactEventListener.trapCapturedEvent(\n topLevelTypes.topFocus,\n 'focus',\n mountAt\n );\n ReactBrowserEventEmitter.ReactEventListener.trapCapturedEvent(\n topLevelTypes.topBlur,\n 'blur',\n mountAt\n );\n } else if (isEventSupported('focusin')) {\n // IE has `focusin` and `focusout` events which bubble.\n // @see http://www.quirksmode.org/blog/archives/2008/04/delegating_the.html\n ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent(\n topLevelTypes.topFocus,\n 'focusin',\n mountAt\n );\n ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent(\n topLevelTypes.topBlur,\n 'focusout',\n mountAt\n );\n }\n\n // to make sure blur and focus event listeners are only attached once\n isListening[topLevelTypes.topBlur] = true;\n isListening[topLevelTypes.topFocus] = true;\n } else if (topEventMapping.hasOwnProperty(dependency)) {\n ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent(\n dependency,\n topEventMapping[dependency],\n mountAt\n );\n }\n\n isListening[dependency] = true;\n }\n }\n },\n\n trapBubbledEvent: function(topLevelType, handlerBaseName, handle) {\n return ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent(\n topLevelType,\n handlerBaseName,\n handle\n );\n },\n\n trapCapturedEvent: function(topLevelType, handlerBaseName, handle) {\n return ReactBrowserEventEmitter.ReactEventListener.trapCapturedEvent(\n topLevelType,\n handlerBaseName,\n handle\n );\n },\n\n /**\n * Listens to window scroll and resize events. We cache scroll values so that\n * application code can access them without triggering reflows.\n *\n * NOTE: Scroll events do not bubble.\n *\n * @see http://www.quirksmode.org/dom/events/scroll.html\n */\n ensureScrollValueMonitoring: function() {\n if (!isMonitoringScrollValue) {\n var refresh = ViewportMetrics.refreshScrollValues;\n ReactBrowserEventEmitter.ReactEventListener.monitorScrollValue(refresh);\n isMonitoringScrollValue = true;\n }\n },\n\n eventNameDispatchConfigs: EventPluginHub.eventNameDispatchConfigs,\n\n registrationNameModules: EventPluginHub.registrationNameModules,\n\n putListener: EventPluginHub.putListener,\n\n getListener: EventPluginHub.getListener,\n\n deleteListener: EventPluginHub.deleteListener,\n\n deleteAllListeners: EventPluginHub.deleteAllListeners\n\n});\n\nmodule.exports = ReactBrowserEventEmitter;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactBrowserEventEmitter.js\n ** module id = 65\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ReactBrowserEventEmitter.js?");
|
||
|
||
/***/ },
|
||
/* 66 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\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 EventConstants\n */\n\n'use strict';\n\nvar keyMirror = __webpack_require__(67);\n\nvar PropagationPhases = keyMirror({bubbled: null, captured: null});\n\n/**\n * Types of raw signals from the browser caught at the top level.\n */\nvar topLevelTypes = keyMirror({\n topBlur: null,\n topChange: null,\n topClick: null,\n topCompositionEnd: null,\n topCompositionStart: null,\n topCompositionUpdate: null,\n topContextMenu: null,\n topCopy: null,\n topCut: null,\n topDoubleClick: null,\n topDrag: null,\n topDragEnd: null,\n topDragEnter: null,\n topDragExit: null,\n topDragLeave: null,\n topDragOver: null,\n topDragStart: null,\n topDrop: null,\n topError: null,\n topFocus: null,\n topInput: null,\n topKeyDown: null,\n topKeyPress: null,\n topKeyUp: null,\n topLoad: null,\n topMouseDown: null,\n topMouseMove: null,\n topMouseOut: null,\n topMouseOver: null,\n topMouseUp: null,\n topPaste: null,\n topReset: null,\n topScroll: null,\n topSelectionChange: null,\n topSubmit: null,\n topTextInput: null,\n topTouchCancel: null,\n topTouchEnd: null,\n topTouchMove: null,\n topTouchStart: null,\n topWheel: null\n});\n\nvar EventConstants = {\n topLevelTypes: topLevelTypes,\n PropagationPhases: PropagationPhases\n};\n\nmodule.exports = EventConstants;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/EventConstants.js\n ** module id = 66\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/EventConstants.js?");
|
||
|
||
/***/ },
|
||
/* 67 */
|
||
/***/ 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 keyMirror\n * @typechecks static-only\n */\n\n'use strict';\n\nvar invariant = __webpack_require__(64);\n\n/**\n * Constructs an enumeration with keys equal to their value.\n *\n * For example:\n *\n * var COLORS = keyMirror({blue: null, red: null});\n * var myColor = COLORS.blue;\n * var isColorValid = !!COLORS[myColor];\n *\n * The last line could not be performed if the values of the generated enum were\n * not equal to their keys.\n *\n * Input: {key1: val1, key2: val2}\n * Output: {key1: key1, key2: key2}\n *\n * @param {object} obj\n * @return {object}\n */\nvar keyMirror = function(obj) {\n var ret = {};\n var key;\n (\"production\" !== process.env.NODE_ENV ? invariant(\n obj instanceof Object && !Array.isArray(obj),\n 'keyMirror(...): Argument must be an object.'\n ) : invariant(obj instanceof Object && !Array.isArray(obj)));\n for (key in obj) {\n if (!obj.hasOwnProperty(key)) {\n continue;\n }\n ret[key] = key;\n }\n return ret;\n};\n\nmodule.exports = keyMirror;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/keyMirror.js\n ** module id = 67\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/keyMirror.js?");
|
||
|
||
/***/ },
|
||
/* 68 */
|
||
/***/ 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 EventPluginHub\n */\n\n'use strict';\n\nvar EventPluginRegistry = __webpack_require__(69);\nvar EventPluginUtils = __webpack_require__(70);\n\nvar accumulateInto = __webpack_require__(71);\nvar forEachAccumulated = __webpack_require__(72);\nvar invariant = __webpack_require__(64);\n\n/**\n * Internal store for event listeners\n */\nvar listenerBank = {};\n\n/**\n * Internal queue of events that have accumulated their dispatches and are\n * waiting to have their dispatches executed.\n */\nvar eventQueue = null;\n\n/**\n * Dispatches an event and releases it back into the pool, unless persistent.\n *\n * @param {?object} event Synthetic event to be dispatched.\n * @private\n */\nvar executeDispatchesAndRelease = function(event) {\n if (event) {\n var executeDispatch = EventPluginUtils.executeDispatch;\n // Plugins can provide custom behavior when dispatching events.\n var PluginModule = EventPluginRegistry.getPluginModuleForEvent(event);\n if (PluginModule && PluginModule.executeDispatch) {\n executeDispatch = PluginModule.executeDispatch;\n }\n EventPluginUtils.executeDispatchesInOrder(event, executeDispatch);\n\n if (!event.isPersistent()) {\n event.constructor.release(event);\n }\n }\n};\n\n/**\n * - `InstanceHandle`: [required] Module that performs logical traversals of DOM\n * hierarchy given ids of the logical DOM elements involved.\n */\nvar InstanceHandle = null;\n\nfunction validateInstanceHandle() {\n var valid =\n InstanceHandle &&\n InstanceHandle.traverseTwoPhase &&\n InstanceHandle.traverseEnterLeave;\n (\"production\" !== process.env.NODE_ENV ? invariant(\n valid,\n 'InstanceHandle not injected before use!'\n ) : invariant(valid));\n}\n\n/**\n * This is a unified interface for event plugins to be installed and configured.\n *\n * Event plugins can implement the following properties:\n *\n * `extractEvents` {function(string, DOMEventTarget, string, object): *}\n * Required. When a top-level event is fired, this method is expected to\n * extract synthetic events that will in turn be queued and dispatched.\n *\n * `eventTypes` {object}\n * Optional, plugins that fire events must publish a mapping of registration\n * names that are used to register listeners. Values of this mapping must\n * be objects that contain `registrationName` or `phasedRegistrationNames`.\n *\n * `executeDispatch` {function(object, function, string)}\n * Optional, allows plugins to override how an event gets dispatched. By\n * default, the listener is simply invoked.\n *\n * Each plugin that is injected into `EventsPluginHub` is immediately operable.\n *\n * @public\n */\nvar EventPluginHub = {\n\n /**\n * Methods for injecting dependencies.\n */\n injection: {\n\n /**\n * @param {object} InjectedMount\n * @public\n */\n injectMount: EventPluginUtils.injection.injectMount,\n\n /**\n * @param {object} InjectedInstanceHandle\n * @public\n */\n injectInstanceHandle: function(InjectedInstanceHandle) {\n InstanceHandle = InjectedInstanceHandle;\n if (\"production\" !== process.env.NODE_ENV) {\n validateInstanceHandle();\n }\n },\n\n getInstanceHandle: function() {\n if (\"production\" !== process.env.NODE_ENV) {\n validateInstanceHandle();\n }\n return InstanceHandle;\n },\n\n /**\n * @param {array} InjectedEventPluginOrder\n * @public\n */\n injectEventPluginOrder: EventPluginRegistry.injectEventPluginOrder,\n\n /**\n * @param {object} injectedNamesToPlugins Map from names to plugin modules.\n */\n injectEventPluginsByName: EventPluginRegistry.injectEventPluginsByName\n\n },\n\n eventNameDispatchConfigs: EventPluginRegistry.eventNameDispatchConfigs,\n\n registrationNameModules: EventPluginRegistry.registrationNameModules,\n\n /**\n * Stores `listener` at `listenerBank[registrationName][id]`. Is idempotent.\n *\n * @param {string} id ID of the DOM element.\n * @param {string} registrationName Name of listener (e.g. `onClick`).\n * @param {?function} listener The callback to store.\n */\n putListener: function(id, registrationName, listener) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n !listener || typeof listener === 'function',\n 'Expected %s listener to be a function, instead got type %s',\n registrationName, typeof listener\n ) : invariant(!listener || typeof listener === 'function'));\n\n var bankForRegistrationName =\n listenerBank[registrationName] || (listenerBank[registrationName] = {});\n bankForRegistrationName[id] = listener;\n },\n\n /**\n * @param {string} id ID of the DOM element.\n * @param {string} registrationName Name of listener (e.g. `onClick`).\n * @return {?function} The stored callback.\n */\n getListener: function(id, registrationName) {\n var bankForRegistrationName = listenerBank[registrationName];\n return bankForRegistrationName && bankForRegistrationName[id];\n },\n\n /**\n * Deletes a listener from the registration bank.\n *\n * @param {string} id ID of the DOM element.\n * @param {string} registrationName Name of listener (e.g. `onClick`).\n */\n deleteListener: function(id, registrationName) {\n var bankForRegistrationName = listenerBank[registrationName];\n if (bankForRegistrationName) {\n delete bankForRegistrationName[id];\n }\n },\n\n /**\n * Deletes all listeners for the DOM element with the supplied ID.\n *\n * @param {string} id ID of the DOM element.\n */\n deleteAllListeners: function(id) {\n for (var registrationName in listenerBank) {\n delete listenerBank[registrationName][id];\n }\n },\n\n /**\n * Allows registered plugins an opportunity to extract events from top-level\n * native browser events.\n *\n * @param {string} topLevelType Record from `EventConstants`.\n * @param {DOMEventTarget} topLevelTarget The listening component root node.\n * @param {string} topLevelTargetID ID of `topLevelTarget`.\n * @param {object} nativeEvent Native browser event.\n * @return {*} An accumulation of synthetic events.\n * @internal\n */\n extractEvents: function(\n topLevelType,\n topLevelTarget,\n topLevelTargetID,\n nativeEvent) {\n var events;\n var plugins = EventPluginRegistry.plugins;\n for (var i = 0, l = plugins.length; i < l; i++) {\n // Not every plugin in the ordering may be loaded at runtime.\n var possiblePlugin = plugins[i];\n if (possiblePlugin) {\n var extractedEvents = possiblePlugin.extractEvents(\n topLevelType,\n topLevelTarget,\n topLevelTargetID,\n nativeEvent\n );\n if (extractedEvents) {\n events = accumulateInto(events, extractedEvents);\n }\n }\n }\n return events;\n },\n\n /**\n * Enqueues a synthetic event that should be dispatched when\n * `processEventQueue` is invoked.\n *\n * @param {*} events An accumulation of synthetic events.\n * @internal\n */\n enqueueEvents: function(events) {\n if (events) {\n eventQueue = accumulateInto(eventQueue, events);\n }\n },\n\n /**\n * Dispatches all synthetic events on the event queue.\n *\n * @internal\n */\n processEventQueue: function() {\n // Set `eventQueue` to null before processing it so that we can tell if more\n // events get enqueued while processing.\n var processingEventQueue = eventQueue;\n eventQueue = null;\n forEachAccumulated(processingEventQueue, executeDispatchesAndRelease);\n (\"production\" !== process.env.NODE_ENV ? invariant(\n !eventQueue,\n 'processEventQueue(): Additional events were enqueued while processing ' +\n 'an event queue. Support for this has not yet been implemented.'\n ) : invariant(!eventQueue));\n },\n\n /**\n * These are needed for tests only. Do not use!\n */\n __purge: function() {\n listenerBank = {};\n },\n\n __getListenerBank: function() {\n return listenerBank;\n }\n\n};\n\nmodule.exports = EventPluginHub;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/EventPluginHub.js\n ** module id = 68\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/EventPluginHub.js?");
|
||
|
||
/***/ },
|
||
/* 69 */
|
||
/***/ 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 EventPluginRegistry\n * @typechecks static-only\n */\n\n'use strict';\n\nvar invariant = __webpack_require__(64);\n\n/**\n * Injectable ordering of event plugins.\n */\nvar EventPluginOrder = null;\n\n/**\n * Injectable mapping from names to event plugin modules.\n */\nvar namesToPlugins = {};\n\n/**\n * Recomputes the plugin list using the injected plugins and plugin ordering.\n *\n * @private\n */\nfunction recomputePluginOrdering() {\n if (!EventPluginOrder) {\n // Wait until an `EventPluginOrder` is injected.\n return;\n }\n for (var pluginName in namesToPlugins) {\n var PluginModule = namesToPlugins[pluginName];\n var pluginIndex = EventPluginOrder.indexOf(pluginName);\n (\"production\" !== process.env.NODE_ENV ? invariant(\n pluginIndex > -1,\n 'EventPluginRegistry: Cannot inject event plugins that do not exist in ' +\n 'the plugin ordering, `%s`.',\n pluginName\n ) : invariant(pluginIndex > -1));\n if (EventPluginRegistry.plugins[pluginIndex]) {\n continue;\n }\n (\"production\" !== process.env.NODE_ENV ? invariant(\n PluginModule.extractEvents,\n 'EventPluginRegistry: Event plugins must implement an `extractEvents` ' +\n 'method, but `%s` does not.',\n pluginName\n ) : invariant(PluginModule.extractEvents));\n EventPluginRegistry.plugins[pluginIndex] = PluginModule;\n var publishedEvents = PluginModule.eventTypes;\n for (var eventName in publishedEvents) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n publishEventForPlugin(\n publishedEvents[eventName],\n PluginModule,\n eventName\n ),\n 'EventPluginRegistry: Failed to publish event `%s` for plugin `%s`.',\n eventName,\n pluginName\n ) : invariant(publishEventForPlugin(\n publishedEvents[eventName],\n PluginModule,\n eventName\n )));\n }\n }\n}\n\n/**\n * Publishes an event so that it can be dispatched by the supplied plugin.\n *\n * @param {object} dispatchConfig Dispatch configuration for the event.\n * @param {object} PluginModule Plugin publishing the event.\n * @return {boolean} True if the event was successfully published.\n * @private\n */\nfunction publishEventForPlugin(dispatchConfig, PluginModule, eventName) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n !EventPluginRegistry.eventNameDispatchConfigs.hasOwnProperty(eventName),\n 'EventPluginHub: More than one plugin attempted to publish the same ' +\n 'event name, `%s`.',\n eventName\n ) : invariant(!EventPluginRegistry.eventNameDispatchConfigs.hasOwnProperty(eventName)));\n EventPluginRegistry.eventNameDispatchConfigs[eventName] = dispatchConfig;\n\n var phasedRegistrationNames = dispatchConfig.phasedRegistrationNames;\n if (phasedRegistrationNames) {\n for (var phaseName in phasedRegistrationNames) {\n if (phasedRegistrationNames.hasOwnProperty(phaseName)) {\n var phasedRegistrationName = phasedRegistrationNames[phaseName];\n publishRegistrationName(\n phasedRegistrationName,\n PluginModule,\n eventName\n );\n }\n }\n return true;\n } else if (dispatchConfig.registrationName) {\n publishRegistrationName(\n dispatchConfig.registrationName,\n PluginModule,\n eventName\n );\n return true;\n }\n return false;\n}\n\n/**\n * Publishes a registration name that is used to identify dispatched events and\n * can be used with `EventPluginHub.putListener` to register listeners.\n *\n * @param {string} registrationName Registration name to add.\n * @param {object} PluginModule Plugin publishing the event.\n * @private\n */\nfunction publishRegistrationName(registrationName, PluginModule, eventName) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n !EventPluginRegistry.registrationNameModules[registrationName],\n 'EventPluginHub: More than one plugin attempted to publish the same ' +\n 'registration name, `%s`.',\n registrationName\n ) : invariant(!EventPluginRegistry.registrationNameModules[registrationName]));\n EventPluginRegistry.registrationNameModules[registrationName] = PluginModule;\n EventPluginRegistry.registrationNameDependencies[registrationName] =\n PluginModule.eventTypes[eventName].dependencies;\n}\n\n/**\n * Registers plugins so that they can extract and dispatch events.\n *\n * @see {EventPluginHub}\n */\nvar EventPluginRegistry = {\n\n /**\n * Ordered list of injected plugins.\n */\n plugins: [],\n\n /**\n * Mapping from event name to dispatch config\n */\n eventNameDispatchConfigs: {},\n\n /**\n * Mapping from registration name to plugin module\n */\n registrationNameModules: {},\n\n /**\n * Mapping from registration name to event name\n */\n registrationNameDependencies: {},\n\n /**\n * Injects an ordering of plugins (by plugin name). This allows the ordering\n * to be decoupled from injection of the actual plugins so that ordering is\n * always deterministic regardless of packaging, on-the-fly injection, etc.\n *\n * @param {array} InjectedEventPluginOrder\n * @internal\n * @see {EventPluginHub.injection.injectEventPluginOrder}\n */\n injectEventPluginOrder: function(InjectedEventPluginOrder) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n !EventPluginOrder,\n 'EventPluginRegistry: Cannot inject event plugin ordering more than ' +\n 'once. You are likely trying to load more than one copy of React.'\n ) : invariant(!EventPluginOrder));\n // Clone the ordering so it cannot be dynamically mutated.\n EventPluginOrder = Array.prototype.slice.call(InjectedEventPluginOrder);\n recomputePluginOrdering();\n },\n\n /**\n * Injects plugins to be used by `EventPluginHub`. The plugin names must be\n * in the ordering injected by `injectEventPluginOrder`.\n *\n * Plugins can be injected as part of page initialization or on-the-fly.\n *\n * @param {object} injectedNamesToPlugins Map from names to plugin modules.\n * @internal\n * @see {EventPluginHub.injection.injectEventPluginsByName}\n */\n injectEventPluginsByName: function(injectedNamesToPlugins) {\n var isOrderingDirty = false;\n for (var pluginName in injectedNamesToPlugins) {\n if (!injectedNamesToPlugins.hasOwnProperty(pluginName)) {\n continue;\n }\n var PluginModule = injectedNamesToPlugins[pluginName];\n if (!namesToPlugins.hasOwnProperty(pluginName) ||\n namesToPlugins[pluginName] !== PluginModule) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n !namesToPlugins[pluginName],\n 'EventPluginRegistry: Cannot inject two different event plugins ' +\n 'using the same name, `%s`.',\n pluginName\n ) : invariant(!namesToPlugins[pluginName]));\n namesToPlugins[pluginName] = PluginModule;\n isOrderingDirty = true;\n }\n }\n if (isOrderingDirty) {\n recomputePluginOrdering();\n }\n },\n\n /**\n * Looks up the plugin for the supplied event.\n *\n * @param {object} event A synthetic event.\n * @return {?object} The plugin that created the supplied event.\n * @internal\n */\n getPluginModuleForEvent: function(event) {\n var dispatchConfig = event.dispatchConfig;\n if (dispatchConfig.registrationName) {\n return EventPluginRegistry.registrationNameModules[\n dispatchConfig.registrationName\n ] || null;\n }\n for (var phase in dispatchConfig.phasedRegistrationNames) {\n if (!dispatchConfig.phasedRegistrationNames.hasOwnProperty(phase)) {\n continue;\n }\n var PluginModule = EventPluginRegistry.registrationNameModules[\n dispatchConfig.phasedRegistrationNames[phase]\n ];\n if (PluginModule) {\n return PluginModule;\n }\n }\n return null;\n },\n\n /**\n * Exposed for unit testing.\n * @private\n */\n _resetEventPlugins: function() {\n EventPluginOrder = null;\n for (var pluginName in namesToPlugins) {\n if (namesToPlugins.hasOwnProperty(pluginName)) {\n delete namesToPlugins[pluginName];\n }\n }\n EventPluginRegistry.plugins.length = 0;\n\n var eventNameDispatchConfigs = EventPluginRegistry.eventNameDispatchConfigs;\n for (var eventName in eventNameDispatchConfigs) {\n if (eventNameDispatchConfigs.hasOwnProperty(eventName)) {\n delete eventNameDispatchConfigs[eventName];\n }\n }\n\n var registrationNameModules = EventPluginRegistry.registrationNameModules;\n for (var registrationName in registrationNameModules) {\n if (registrationNameModules.hasOwnProperty(registrationName)) {\n delete registrationNameModules[registrationName];\n }\n }\n }\n\n};\n\nmodule.exports = EventPluginRegistry;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/EventPluginRegistry.js\n ** module id = 69\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/EventPluginRegistry.js?");
|
||
|
||
/***/ },
|
||
/* 70 */
|
||
/***/ 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 EventPluginUtils\n */\n\n'use strict';\n\nvar EventConstants = __webpack_require__(66);\n\nvar invariant = __webpack_require__(64);\n\n/**\n * Injected dependencies:\n */\n\n/**\n * - `Mount`: [required] Module that can convert between React dom IDs and\n * actual node references.\n */\nvar injection = {\n Mount: null,\n injectMount: function(InjectedMount) {\n injection.Mount = InjectedMount;\n if (\"production\" !== process.env.NODE_ENV) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n InjectedMount && InjectedMount.getNode,\n 'EventPluginUtils.injection.injectMount(...): Injected Mount module ' +\n 'is missing getNode.'\n ) : invariant(InjectedMount && InjectedMount.getNode));\n }\n }\n};\n\nvar topLevelTypes = EventConstants.topLevelTypes;\n\nfunction isEndish(topLevelType) {\n return topLevelType === topLevelTypes.topMouseUp ||\n topLevelType === topLevelTypes.topTouchEnd ||\n topLevelType === topLevelTypes.topTouchCancel;\n}\n\nfunction isMoveish(topLevelType) {\n return topLevelType === topLevelTypes.topMouseMove ||\n topLevelType === topLevelTypes.topTouchMove;\n}\nfunction isStartish(topLevelType) {\n return topLevelType === topLevelTypes.topMouseDown ||\n topLevelType === topLevelTypes.topTouchStart;\n}\n\n\nvar validateEventDispatches;\nif (\"production\" !== process.env.NODE_ENV) {\n validateEventDispatches = function(event) {\n var dispatchListeners = event._dispatchListeners;\n var dispatchIDs = event._dispatchIDs;\n\n var listenersIsArr = Array.isArray(dispatchListeners);\n var idsIsArr = Array.isArray(dispatchIDs);\n var IDsLen = idsIsArr ? dispatchIDs.length : dispatchIDs ? 1 : 0;\n var listenersLen = listenersIsArr ?\n dispatchListeners.length :\n dispatchListeners ? 1 : 0;\n\n (\"production\" !== process.env.NODE_ENV ? invariant(\n idsIsArr === listenersIsArr && IDsLen === listenersLen,\n 'EventPluginUtils: Invalid `event`.'\n ) : invariant(idsIsArr === listenersIsArr && IDsLen === listenersLen));\n };\n}\n\n/**\n * Invokes `cb(event, listener, id)`. Avoids using call if no scope is\n * provided. The `(listener,id)` pair effectively forms the \"dispatch\" but are\n * kept separate to conserve memory.\n */\nfunction forEachEventDispatch(event, cb) {\n var dispatchListeners = event._dispatchListeners;\n var dispatchIDs = event._dispatchIDs;\n if (\"production\" !== process.env.NODE_ENV) {\n validateEventDispatches(event);\n }\n if (Array.isArray(dispatchListeners)) {\n for (var i = 0; i < dispatchListeners.length; i++) {\n if (event.isPropagationStopped()) {\n break;\n }\n // Listeners and IDs are two parallel arrays that are always in sync.\n cb(event, dispatchListeners[i], dispatchIDs[i]);\n }\n } else if (dispatchListeners) {\n cb(event, dispatchListeners, dispatchIDs);\n }\n}\n\n/**\n * Default implementation of PluginModule.executeDispatch().\n * @param {SyntheticEvent} SyntheticEvent to handle\n * @param {function} Application-level callback\n * @param {string} domID DOM id to pass to the callback.\n */\nfunction executeDispatch(event, listener, domID) {\n event.currentTarget = injection.Mount.getNode(domID);\n var returnValue = listener(event, domID);\n event.currentTarget = null;\n return returnValue;\n}\n\n/**\n * Standard/simple iteration through an event's collected dispatches.\n */\nfunction executeDispatchesInOrder(event, cb) {\n forEachEventDispatch(event, cb);\n event._dispatchListeners = null;\n event._dispatchIDs = null;\n}\n\n/**\n * Standard/simple iteration through an event's collected dispatches, but stops\n * at the first dispatch execution returning true, and returns that id.\n *\n * @return id of the first dispatch execution who's listener returns true, or\n * null if no listener returned true.\n */\nfunction executeDispatchesInOrderStopAtTrueImpl(event) {\n var dispatchListeners = event._dispatchListeners;\n var dispatchIDs = event._dispatchIDs;\n if (\"production\" !== process.env.NODE_ENV) {\n validateEventDispatches(event);\n }\n if (Array.isArray(dispatchListeners)) {\n for (var i = 0; i < dispatchListeners.length; i++) {\n if (event.isPropagationStopped()) {\n break;\n }\n // Listeners and IDs are two parallel arrays that are always in sync.\n if (dispatchListeners[i](event, dispatchIDs[i])) {\n return dispatchIDs[i];\n }\n }\n } else if (dispatchListeners) {\n if (dispatchListeners(event, dispatchIDs)) {\n return dispatchIDs;\n }\n }\n return null;\n}\n\n/**\n * @see executeDispatchesInOrderStopAtTrueImpl\n */\nfunction executeDispatchesInOrderStopAtTrue(event) {\n var ret = executeDispatchesInOrderStopAtTrueImpl(event);\n event._dispatchIDs = null;\n event._dispatchListeners = null;\n return ret;\n}\n\n/**\n * Execution of a \"direct\" dispatch - there must be at most one dispatch\n * accumulated on the event or it is considered an error. It doesn't really make\n * sense for an event with multiple dispatches (bubbled) to keep track of the\n * return values at each dispatch execution, but it does tend to make sense when\n * dealing with \"direct\" dispatches.\n *\n * @return The return value of executing the single dispatch.\n */\nfunction executeDirectDispatch(event) {\n if (\"production\" !== process.env.NODE_ENV) {\n validateEventDispatches(event);\n }\n var dispatchListener = event._dispatchListeners;\n var dispatchID = event._dispatchIDs;\n (\"production\" !== process.env.NODE_ENV ? invariant(\n !Array.isArray(dispatchListener),\n 'executeDirectDispatch(...): Invalid `event`.'\n ) : invariant(!Array.isArray(dispatchListener)));\n var res = dispatchListener ?\n dispatchListener(event, dispatchID) :\n null;\n event._dispatchListeners = null;\n event._dispatchIDs = null;\n return res;\n}\n\n/**\n * @param {SyntheticEvent} event\n * @return {bool} True iff number of dispatches accumulated is greater than 0.\n */\nfunction hasDispatches(event) {\n return !!event._dispatchListeners;\n}\n\n/**\n * General utilities that are useful in creating custom Event Plugins.\n */\nvar EventPluginUtils = {\n isEndish: isEndish,\n isMoveish: isMoveish,\n isStartish: isStartish,\n\n executeDirectDispatch: executeDirectDispatch,\n executeDispatch: executeDispatch,\n executeDispatchesInOrder: executeDispatchesInOrder,\n executeDispatchesInOrderStopAtTrue: executeDispatchesInOrderStopAtTrue,\n hasDispatches: hasDispatches,\n injection: injection,\n useTouchEvents: false\n};\n\nmodule.exports = EventPluginUtils;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/EventPluginUtils.js\n ** module id = 70\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/EventPluginUtils.js?");
|
||
|
||
/***/ },
|
||
/* 71 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/* WEBPACK VAR INJECTION */(function(process) {/**\n * Copyright 2014-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 accumulateInto\n */\n\n'use strict';\n\nvar invariant = __webpack_require__(64);\n\n/**\n *\n * Accumulates items that must not be null or undefined into the first one. This\n * is used to conserve memory by avoiding array allocations, and thus sacrifices\n * API cleanness. Since `current` can be null before being passed in and not\n * null after this function, make sure to assign it back to `current`:\n *\n * `a = accumulateInto(a, b);`\n *\n * This API should be sparingly used. Try `accumulate` for something cleaner.\n *\n * @return {*|array<*>} An accumulation of items.\n */\n\nfunction accumulateInto(current, next) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n next != null,\n 'accumulateInto(...): Accumulated items must not be null or undefined.'\n ) : invariant(next != null));\n if (current == null) {\n return next;\n }\n\n // Both are not empty. Warning: Never call x.concat(y) when you are not\n // certain that x is an Array (x could be a string with concat method).\n var currentIsArray = Array.isArray(current);\n var nextIsArray = Array.isArray(next);\n\n if (currentIsArray && nextIsArray) {\n current.push.apply(current, next);\n return current;\n }\n\n if (currentIsArray) {\n current.push(next);\n return current;\n }\n\n if (nextIsArray) {\n // A bit too dangerous to mutate `next`.\n return [current].concat(next);\n }\n\n return [current, next];\n}\n\nmodule.exports = accumulateInto;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/accumulateInto.js\n ** module id = 71\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/accumulateInto.js?");
|
||
|
||
/***/ },
|
||
/* 72 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("/**\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 forEachAccumulated\n */\n\n'use strict';\n\n/**\n * @param {array} an \"accumulation\" of items which is either an Array or\n * a single item. Useful when paired with the `accumulate` module. This is a\n * simple utility that allows us to reason about a collection of items, but\n * handling the case when there is exactly one item (and we do not need to\n * allocate an array).\n */\nvar forEachAccumulated = function(arr, cb, scope) {\n if (Array.isArray(arr)) {\n arr.forEach(cb, scope);\n } else if (arr) {\n cb.call(scope, arr);\n }\n};\n\nmodule.exports = forEachAccumulated;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/forEachAccumulated.js\n ** module id = 72\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/forEachAccumulated.js?");
|
||
|
||
/***/ },
|
||
/* 73 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\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 ReactEventEmitterMixin\n */\n\n'use strict';\n\nvar EventPluginHub = __webpack_require__(68);\n\nfunction runEventQueueInBatch(events) {\n EventPluginHub.enqueueEvents(events);\n EventPluginHub.processEventQueue();\n}\n\nvar ReactEventEmitterMixin = {\n\n /**\n * Streams a fired top-level event to `EventPluginHub` where plugins have the\n * opportunity to create `ReactEvent`s to be dispatched.\n *\n * @param {string} topLevelType Record from `EventConstants`.\n * @param {object} topLevelTarget The listening component root node.\n * @param {string} topLevelTargetID ID of `topLevelTarget`.\n * @param {object} nativeEvent Native environment event.\n */\n handleTopLevel: function(\n topLevelType,\n topLevelTarget,\n topLevelTargetID,\n nativeEvent) {\n var events = EventPluginHub.extractEvents(\n topLevelType,\n topLevelTarget,\n topLevelTargetID,\n nativeEvent\n );\n\n runEventQueueInBatch(events);\n }\n};\n\nmodule.exports = ReactEventEmitterMixin;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactEventEmitterMixin.js\n ** module id = 73\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ReactEventEmitterMixin.js?");
|
||
|
||
/***/ },
|
||
/* 74 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("/**\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 ViewportMetrics\n */\n\n'use strict';\n\nvar ViewportMetrics = {\n\n currentScrollLeft: 0,\n\n currentScrollTop: 0,\n\n refreshScrollValues: function(scrollPosition) {\n ViewportMetrics.currentScrollLeft = scrollPosition.x;\n ViewportMetrics.currentScrollTop = scrollPosition.y;\n }\n\n};\n\nmodule.exports = ViewportMetrics;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ViewportMetrics.js\n ** module id = 74\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ViewportMetrics.js?");
|
||
|
||
/***/ },
|
||
/* 75 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("/**\n * Copyright 2014-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 Object.assign\n */\n\n// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-object.assign\n\n'use strict';\n\nfunction assign(target, sources) {\n if (target == null) {\n throw new TypeError('Object.assign target cannot be null or undefined');\n }\n\n var to = Object(target);\n var hasOwnProperty = Object.prototype.hasOwnProperty;\n\n for (var nextIndex = 1; nextIndex < arguments.length; nextIndex++) {\n var nextSource = arguments[nextIndex];\n if (nextSource == null) {\n continue;\n }\n\n var from = Object(nextSource);\n\n // We don't currently support accessors nor proxies. Therefore this\n // copy cannot throw. If we ever supported this then we must handle\n // exceptions and side-effects. We don't support symbols so they won't\n // be transferred.\n\n for (var key in from) {\n if (hasOwnProperty.call(from, key)) {\n to[key] = from[key];\n }\n }\n }\n\n return to;\n}\n\nmodule.exports = assign;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/Object.assign.js\n ** module id = 75\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/Object.assign.js?");
|
||
|
||
/***/ },
|
||
/* 76 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\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 isEventSupported\n */\n\n'use strict';\n\nvar ExecutionEnvironment = __webpack_require__(77);\n\nvar useHasFeature;\nif (ExecutionEnvironment.canUseDOM) {\n useHasFeature =\n document.implementation &&\n document.implementation.hasFeature &&\n // always returns true in newer browsers as per the standard.\n // @see http://dom.spec.whatwg.org/#dom-domimplementation-hasfeature\n document.implementation.hasFeature('', '') !== true;\n}\n\n/**\n * Checks if an event is supported in the current execution environment.\n *\n * NOTE: This will not work correctly for non-generic events such as `change`,\n * `reset`, `load`, `error`, and `select`.\n *\n * Borrows from Modernizr.\n *\n * @param {string} eventNameSuffix Event name, e.g. \"click\".\n * @param {?boolean} capture Check if the capture phase is supported.\n * @return {boolean} True if the event is supported.\n * @internal\n * @license Modernizr 3.0.0pre (Custom Build) | MIT\n */\nfunction isEventSupported(eventNameSuffix, capture) {\n if (!ExecutionEnvironment.canUseDOM ||\n capture && !('addEventListener' in document)) {\n return false;\n }\n\n var eventName = 'on' + eventNameSuffix;\n var isSupported = eventName in document;\n\n if (!isSupported) {\n var element = document.createElement('div');\n element.setAttribute(eventName, 'return;');\n isSupported = typeof element[eventName] === 'function';\n }\n\n if (!isSupported && useHasFeature && eventNameSuffix === 'wheel') {\n // This is the only way to test support for the `wheel` event in IE9+.\n isSupported = document.implementation.hasFeature('Events.wheel', '3.0');\n }\n\n return isSupported;\n}\n\nmodule.exports = isEventSupported;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/isEventSupported.js\n ** module id = 76\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/isEventSupported.js?");
|
||
|
||
/***/ },
|
||
/* 77 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("/**\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 ExecutionEnvironment\n */\n\n/*jslint evil: true */\n\n\"use strict\";\n\nvar canUseDOM = !!(\n (typeof window !== 'undefined' &&\n window.document && window.document.createElement)\n);\n\n/**\n * Simple, lightweight module assisting with the detection and context of\n * Worker. Helps avoid circular dependencies and allows code to reason about\n * whether or not they are in a Worker, even if they never include the main\n * `ReactWorker` dependency.\n */\nvar ExecutionEnvironment = {\n\n canUseDOM: canUseDOM,\n\n canUseWorkers: typeof Worker !== 'undefined',\n\n canUseEventListeners:\n canUseDOM && !!(window.addEventListener || window.attachEvent),\n\n canUseViewport: canUseDOM && !!window.screen,\n\n isInWorker: !canUseDOM // For now, this is true - might change in the future.\n\n};\n\nmodule.exports = ExecutionEnvironment;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ExecutionEnvironment.js\n ** module id = 77\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ExecutionEnvironment.js?");
|
||
|
||
/***/ },
|
||
/* 78 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("/**\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 ReactCurrentOwner\n */\n\n'use strict';\n\n/**\n * Keeps track of the current owner.\n *\n * The current owner is the component who should own any components that are\n * currently being constructed.\n *\n * The depth indicate how many composite components are above this render level.\n */\nvar ReactCurrentOwner = {\n\n /**\n * @internal\n * @type {ReactComponent}\n */\n current: null\n\n};\n\nmodule.exports = ReactCurrentOwner;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactCurrentOwner.js\n ** module id = 78\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ReactCurrentOwner.js?");
|
||
|
||
/***/ },
|
||
/* 79 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/* WEBPACK VAR INJECTION */(function(process) {/**\n * Copyright 2014-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 ReactElement\n */\n\n'use strict';\n\nvar ReactContext = __webpack_require__(80);\nvar ReactCurrentOwner = __webpack_require__(78);\n\nvar assign = __webpack_require__(75);\nvar warning = __webpack_require__(82);\n\nvar RESERVED_PROPS = {\n key: true,\n ref: true\n};\n\n/**\n * Warn for mutations.\n *\n * @internal\n * @param {object} object\n * @param {string} key\n */\nfunction defineWarningProperty(object, key) {\n Object.defineProperty(object, key, {\n\n configurable: false,\n enumerable: true,\n\n get: function() {\n if (!this._store) {\n return null;\n }\n return this._store[key];\n },\n\n set: function(value) {\n (\"production\" !== process.env.NODE_ENV ? warning(\n false,\n 'Don\\'t set the %s property of the React element. Instead, ' +\n 'specify the correct value when initially creating the element.',\n key\n ) : null);\n this._store[key] = value;\n }\n\n });\n}\n\n/**\n * This is updated to true if the membrane is successfully created.\n */\nvar useMutationMembrane = false;\n\n/**\n * Warn for mutations.\n *\n * @internal\n * @param {object} element\n */\nfunction defineMutationMembrane(prototype) {\n try {\n var pseudoFrozenProperties = {\n props: true\n };\n for (var key in pseudoFrozenProperties) {\n defineWarningProperty(prototype, key);\n }\n useMutationMembrane = true;\n } catch (x) {\n // IE will fail on defineProperty\n }\n}\n\n/**\n * Base constructor for all React elements. This is only used to make this\n * work with a dynamic instanceof check. Nothing should live on this prototype.\n *\n * @param {*} type\n * @param {string|object} ref\n * @param {*} key\n * @param {*} props\n * @internal\n */\nvar ReactElement = function(type, key, ref, owner, context, props) {\n // Built-in properties that belong on the element\n this.type = type;\n this.key = key;\n this.ref = ref;\n\n // Record the component responsible for creating this element.\n this._owner = owner;\n\n // TODO: Deprecate withContext, and then the context becomes accessible\n // through the owner.\n this._context = context;\n\n if (\"production\" !== process.env.NODE_ENV) {\n // The validation flag and props are currently mutative. We put them on\n // an external backing store so that we can freeze the whole object.\n // This can be replaced with a WeakMap once they are implemented in\n // commonly used development environments.\n this._store = {props: props, originalProps: assign({}, props)};\n\n // To make comparing ReactElements easier for testing purposes, we make\n // the validation flag non-enumerable (where possible, which should\n // include every environment we run tests in), so the test framework\n // ignores it.\n try {\n Object.defineProperty(this._store, 'validated', {\n configurable: false,\n enumerable: false,\n writable: true\n });\n } catch (x) {\n }\n this._store.validated = false;\n\n // We're not allowed to set props directly on the object so we early\n // return and rely on the prototype membrane to forward to the backing\n // store.\n if (useMutationMembrane) {\n Object.freeze(this);\n return;\n }\n }\n\n this.props = props;\n};\n\n// We intentionally don't expose the function on the constructor property.\n// ReactElement should be indistinguishable from a plain object.\nReactElement.prototype = {\n _isReactElement: true\n};\n\nif (\"production\" !== process.env.NODE_ENV) {\n defineMutationMembrane(ReactElement.prototype);\n}\n\nReactElement.createElement = function(type, config, children) {\n var propName;\n\n // Reserved names are extracted\n var props = {};\n\n var key = null;\n var ref = null;\n\n if (config != null) {\n ref = config.ref === undefined ? null : config.ref;\n key = config.key === undefined ? null : '' + config.key;\n // Remaining properties are added to a new props object\n for (propName in config) {\n if (config.hasOwnProperty(propName) &&\n !RESERVED_PROPS.hasOwnProperty(propName)) {\n props[propName] = config[propName];\n }\n }\n }\n\n // Children can be more than one argument, and those are transferred onto\n // the newly allocated props object.\n var childrenLength = arguments.length - 2;\n if (childrenLength === 1) {\n props.children = children;\n } else if (childrenLength > 1) {\n var childArray = Array(childrenLength);\n for (var i = 0; i < childrenLength; i++) {\n childArray[i] = arguments[i + 2];\n }\n props.children = childArray;\n }\n\n // Resolve default props\n if (type && type.defaultProps) {\n var defaultProps = type.defaultProps;\n for (propName in defaultProps) {\n if (typeof props[propName] === 'undefined') {\n props[propName] = defaultProps[propName];\n }\n }\n }\n\n return new ReactElement(\n type,\n key,\n ref,\n ReactCurrentOwner.current,\n ReactContext.current,\n props\n );\n};\n\nReactElement.createFactory = function(type) {\n var factory = ReactElement.createElement.bind(null, type);\n // Expose the type on the factory and the prototype so that it can be\n // easily accessed on elements. E.g. <Foo />.type === Foo.type.\n // This should not be named `constructor` since this may not be the function\n // that created the element, and it may not even be a constructor.\n // Legacy hook TODO: Warn if this is accessed\n factory.type = type;\n return factory;\n};\n\nReactElement.cloneAndReplaceProps = function(oldElement, newProps) {\n var newElement = new ReactElement(\n oldElement.type,\n oldElement.key,\n oldElement.ref,\n oldElement._owner,\n oldElement._context,\n newProps\n );\n\n if (\"production\" !== process.env.NODE_ENV) {\n // If the key on the original is valid, then the clone is valid\n newElement._store.validated = oldElement._store.validated;\n }\n return newElement;\n};\n\nReactElement.cloneElement = function(element, config, children) {\n var propName;\n\n // Original props are copied\n var props = assign({}, element.props);\n\n // Reserved names are extracted\n var key = element.key;\n var ref = element.ref;\n\n // Owner will be preserved, unless ref is overridden\n var owner = element._owner;\n\n if (config != null) {\n if (config.ref !== undefined) {\n // Silently steal the ref from the parent.\n ref = config.ref;\n owner = ReactCurrentOwner.current;\n }\n if (config.key !== undefined) {\n key = '' + config.key;\n }\n // Remaining properties override existing props\n for (propName in config) {\n if (config.hasOwnProperty(propName) &&\n !RESERVED_PROPS.hasOwnProperty(propName)) {\n props[propName] = config[propName];\n }\n }\n }\n\n // Children can be more than one argument, and those are transferred onto\n // the newly allocated props object.\n var childrenLength = arguments.length - 2;\n if (childrenLength === 1) {\n props.children = children;\n } else if (childrenLength > 1) {\n var childArray = Array(childrenLength);\n for (var i = 0; i < childrenLength; i++) {\n childArray[i] = arguments[i + 2];\n }\n props.children = childArray;\n }\n\n return new ReactElement(\n element.type,\n key,\n ref,\n owner,\n element._context,\n props\n );\n};\n\n/**\n * @param {?object} object\n * @return {boolean} True if `object` is a valid component.\n * @final\n */\nReactElement.isValidElement = function(object) {\n // ReactTestUtils is often used outside of beforeEach where as React is\n // within it. This leads to two different instances of React on the same\n // page. To identify a element from a different React instance we use\n // a flag instead of an instanceof check.\n var isElement = !!(object && object._isReactElement);\n // if (isElement && !(object instanceof ReactElement)) {\n // This is an indicator that you're using multiple versions of React at the\n // same time. This will screw with ownership and stuff. Fix it, please.\n // TODO: We could possibly warn here.\n // }\n return isElement;\n};\n\nmodule.exports = ReactElement;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactElement.js\n ** module id = 79\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ReactElement.js?");
|
||
|
||
/***/ },
|
||
/* 80 */
|
||
/***/ 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 ReactContext\n */\n\n'use strict';\n\nvar assign = __webpack_require__(75);\nvar emptyObject = __webpack_require__(81);\nvar warning = __webpack_require__(82);\n\nvar didWarn = false;\n\n/**\n * Keeps track of the current context.\n *\n * The context is automatically passed down the component ownership hierarchy\n * and is accessible via `this.context` on ReactCompositeComponents.\n */\nvar ReactContext = {\n\n /**\n * @internal\n * @type {object}\n */\n current: emptyObject,\n\n /**\n * Temporarily extends the current context while executing scopedCallback.\n *\n * A typical use case might look like\n *\n * render: function() {\n * var children = ReactContext.withContext({foo: 'foo'}, () => (\n *\n * ));\n * return <div>{children}</div>;\n * }\n *\n * @param {object} newContext New context to merge into the existing context\n * @param {function} scopedCallback Callback to run with the new context\n * @return {ReactComponent|array<ReactComponent>}\n */\n withContext: function(newContext, scopedCallback) {\n if (\"production\" !== process.env.NODE_ENV) {\n (\"production\" !== process.env.NODE_ENV ? warning(\n didWarn,\n 'withContext is deprecated and will be removed in a future version. ' +\n 'Use a wrapper component with getChildContext instead.'\n ) : null);\n\n didWarn = true;\n }\n\n var result;\n var previousContext = ReactContext.current;\n ReactContext.current = assign({}, previousContext, newContext);\n try {\n result = scopedCallback();\n } finally {\n ReactContext.current = previousContext;\n }\n return result;\n }\n\n};\n\nmodule.exports = ReactContext;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactContext.js\n ** module id = 80\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ReactContext.js?");
|
||
|
||
/***/ },
|
||
/* 81 */
|
||
/***/ 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 emptyObject\n */\n\n\"use strict\";\n\nvar emptyObject = {};\n\nif (\"production\" !== process.env.NODE_ENV) {\n Object.freeze(emptyObject);\n}\n\nmodule.exports = emptyObject;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/emptyObject.js\n ** module id = 81\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/emptyObject.js?");
|
||
|
||
/***/ },
|
||
/* 82 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/* WEBPACK VAR INJECTION */(function(process) {/**\n * Copyright 2014-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 warning\n */\n\n\"use strict\";\n\nvar emptyFunction = __webpack_require__(83);\n\n/**\n * Similar to invariant but only logs a warning if the condition is not met.\n * This can be used to log issues in development environments in critical\n * paths. Removing the logging code for production environments will keep the\n * same logic and follow the same code paths.\n */\n\nvar warning = emptyFunction;\n\nif (\"production\" !== process.env.NODE_ENV) {\n warning = function(condition, format ) {for (var args=[],$__0=2,$__1=arguments.length;$__0<$__1;$__0++) args.push(arguments[$__0]);\n if (format === undefined) {\n throw new Error(\n '`warning(condition, format, ...args)` requires a warning ' +\n 'message argument'\n );\n }\n\n if (format.length < 10 || /^[s\\W]*$/.test(format)) {\n throw new Error(\n 'The warning format should be able to uniquely identify this ' +\n 'warning. Please, use a more descriptive format than: ' + format\n );\n }\n\n if (format.indexOf('Failed Composite propType: ') === 0) {\n return; // Ignore CompositeComponent proptype check.\n }\n\n if (!condition) {\n var argIndex = 0;\n var message = 'Warning: ' + format.replace(/%s/g, function() {return args[argIndex++];});\n console.warn(message);\n try {\n // --- Welcome to debugging React ---\n // This error was thrown as a convenience so that you can use this stack\n // to find the callsite that caused this warning to fire.\n throw new Error(message);\n } catch(x) {}\n }\n };\n}\n\nmodule.exports = warning;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/warning.js\n ** module id = 82\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/warning.js?");
|
||
|
||
/***/ },
|
||
/* 83 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("/**\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 emptyFunction\n */\n\nfunction makeEmptyFunction(arg) {\n return function() {\n return arg;\n };\n}\n\n/**\n * This function accepts and discards inputs; it has no side effects. This is\n * primarily useful idiomatically for overridable function endpoints which\n * always need to be callable, since JS lacks a null-call idiom ala Cocoa.\n */\nfunction emptyFunction() {}\n\nemptyFunction.thatReturns = makeEmptyFunction;\nemptyFunction.thatReturnsFalse = makeEmptyFunction(false);\nemptyFunction.thatReturnsTrue = makeEmptyFunction(true);\nemptyFunction.thatReturnsNull = makeEmptyFunction(null);\nemptyFunction.thatReturnsThis = function() { return this; };\nemptyFunction.thatReturnsArgument = function(arg) { return arg; };\n\nmodule.exports = emptyFunction;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/emptyFunction.js\n ** module id = 83\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/emptyFunction.js?");
|
||
|
||
/***/ },
|
||
/* 84 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/* WEBPACK VAR INJECTION */(function(process) {/**\n * Copyright 2014-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 ReactElementValidator\n */\n\n/**\n * ReactElementValidator provides a wrapper around a element factory\n * which validates the props passed to the element. This is intended to be\n * used only in DEV and could be replaced by a static type checker for languages\n * that support it.\n */\n\n'use strict';\n\nvar ReactElement = __webpack_require__(79);\nvar ReactFragment = __webpack_require__(85);\nvar ReactPropTypeLocations = __webpack_require__(86);\nvar ReactPropTypeLocationNames = __webpack_require__(87);\nvar ReactCurrentOwner = __webpack_require__(78);\nvar ReactNativeComponent = __webpack_require__(88);\n\nvar getIteratorFn = __webpack_require__(89);\nvar invariant = __webpack_require__(64);\nvar warning = __webpack_require__(82);\n\nfunction getDeclarationErrorAddendum() {\n if (ReactCurrentOwner.current) {\n var name = ReactCurrentOwner.current.getName();\n if (name) {\n return ' Check the render method of `' + name + '`.';\n }\n }\n return '';\n}\n\n/**\n * Warn if there's no key explicitly set on dynamic arrays of children or\n * object keys are not valid. This allows us to keep track of children between\n * updates.\n */\nvar ownerHasKeyUseWarning = {};\n\nvar loggedTypeFailures = {};\n\nvar NUMERIC_PROPERTY_REGEX = /^\\d+$/;\n\n/**\n * Gets the instance's name for use in warnings.\n *\n * @internal\n * @return {?string} Display name or undefined\n */\nfunction getName(instance) {\n var publicInstance = instance && instance.getPublicInstance();\n if (!publicInstance) {\n return undefined;\n }\n var constructor = publicInstance.constructor;\n if (!constructor) {\n return undefined;\n }\n return constructor.displayName || constructor.name || undefined;\n}\n\n/**\n * Gets the current owner's displayName for use in warnings.\n *\n * @internal\n * @return {?string} Display name or undefined\n */\nfunction getCurrentOwnerDisplayName() {\n var current = ReactCurrentOwner.current;\n return (\n current && getName(current) || undefined\n );\n}\n\n/**\n * Warn if the element doesn't have an explicit key assigned to it.\n * This element is in an array. The array could grow and shrink or be\n * reordered. All children that haven't already been validated are required to\n * have a \"key\" property assigned to it.\n *\n * @internal\n * @param {ReactElement} element Element that requires a key.\n * @param {*} parentType element's parent's type.\n */\nfunction validateExplicitKey(element, parentType) {\n if (element._store.validated || element.key != null) {\n return;\n }\n element._store.validated = true;\n\n warnAndMonitorForKeyUse(\n 'Each child in an array or iterator should have a unique \"key\" prop.',\n element,\n parentType\n );\n}\n\n/**\n * Warn if the key is being defined as an object property but has an incorrect\n * value.\n *\n * @internal\n * @param {string} name Property name of the key.\n * @param {ReactElement} element Component that requires a key.\n * @param {*} parentType element's parent's type.\n */\nfunction validatePropertyKey(name, element, parentType) {\n if (!NUMERIC_PROPERTY_REGEX.test(name)) {\n return;\n }\n warnAndMonitorForKeyUse(\n 'Child objects should have non-numeric keys so ordering is preserved.',\n element,\n parentType\n );\n}\n\n/**\n * Shared warning and monitoring code for the key warnings.\n *\n * @internal\n * @param {string} message The base warning that gets output.\n * @param {ReactElement} element Component that requires a key.\n * @param {*} parentType element's parent's type.\n */\nfunction warnAndMonitorForKeyUse(message, element, parentType) {\n var ownerName = getCurrentOwnerDisplayName();\n var parentName = typeof parentType === 'string' ?\n parentType : parentType.displayName || parentType.name;\n\n var useName = ownerName || parentName;\n var memoizer = ownerHasKeyUseWarning[message] || (\n (ownerHasKeyUseWarning[message] = {})\n );\n if (memoizer.hasOwnProperty(useName)) {\n return;\n }\n memoizer[useName] = true;\n\n var parentOrOwnerAddendum =\n ownerName ? (\" Check the render method of \" + ownerName + \".\") :\n parentName ? (\" Check the React.render call using <\" + parentName + \">.\") :\n '';\n\n // Usually the current owner is the offender, but if it accepts children as a\n // property, it may be the creator of the child that's responsible for\n // assigning it a key.\n var childOwnerAddendum = '';\n if (element &&\n element._owner &&\n element._owner !== ReactCurrentOwner.current) {\n // Name of the component that originally created this child.\n var childOwnerName = getName(element._owner);\n\n childOwnerAddendum = (\" It was passed a child from \" + childOwnerName + \".\");\n }\n\n (\"production\" !== process.env.NODE_ENV ? warning(\n false,\n message + '%s%s See https://fb.me/react-warning-keys for more information.',\n parentOrOwnerAddendum,\n childOwnerAddendum\n ) : null);\n}\n\n/**\n * Ensure that every element either is passed in a static location, in an\n * array with an explicit keys property defined, or in an object literal\n * with valid key property.\n *\n * @internal\n * @param {ReactNode} node Statically passed child of any type.\n * @param {*} parentType node's parent's type.\n */\nfunction validateChildKeys(node, parentType) {\n if (Array.isArray(node)) {\n for (var i = 0; i < node.length; i++) {\n var child = node[i];\n if (ReactElement.isValidElement(child)) {\n validateExplicitKey(child, parentType);\n }\n }\n } else if (ReactElement.isValidElement(node)) {\n // This element was passed in a valid location.\n node._store.validated = true;\n } else if (node) {\n var iteratorFn = getIteratorFn(node);\n // Entry iterators provide implicit keys.\n if (iteratorFn) {\n if (iteratorFn !== node.entries) {\n var iterator = iteratorFn.call(node);\n var step;\n while (!(step = iterator.next()).done) {\n if (ReactElement.isValidElement(step.value)) {\n validateExplicitKey(step.value, parentType);\n }\n }\n }\n } else if (typeof node === 'object') {\n var fragment = ReactFragment.extractIfFragment(node);\n for (var key in fragment) {\n if (fragment.hasOwnProperty(key)) {\n validatePropertyKey(key, fragment[key], parentType);\n }\n }\n }\n }\n}\n\n/**\n * Assert that the props are valid\n *\n * @param {string} componentName Name of the component for error messages.\n * @param {object} propTypes Map of prop name to a ReactPropType\n * @param {object} props\n * @param {string} location e.g. \"prop\", \"context\", \"child context\"\n * @private\n */\nfunction checkPropTypes(componentName, propTypes, props, location) {\n for (var propName in propTypes) {\n if (propTypes.hasOwnProperty(propName)) {\n var error;\n // Prop type validation may throw. In case they do, we don't want to\n // fail the render phase where it didn't fail before. So we log it.\n // After these have been cleaned up, we'll let them throw.\n try {\n // This is intentionally an invariant that gets caught. It's the same\n // behavior as without this statement except with a better message.\n (\"production\" !== process.env.NODE_ENV ? invariant(\n typeof propTypes[propName] === 'function',\n '%s: %s type `%s` is invalid; it must be a function, usually from ' +\n 'React.PropTypes.',\n componentName || 'React class',\n ReactPropTypeLocationNames[location],\n propName\n ) : invariant(typeof propTypes[propName] === 'function'));\n error = propTypes[propName](props, propName, componentName, location);\n } catch (ex) {\n error = ex;\n }\n if (error instanceof Error && !(error.message in loggedTypeFailures)) {\n // Only monitor this failure once because there tends to be a lot of the\n // same error.\n loggedTypeFailures[error.message] = true;\n\n var addendum = getDeclarationErrorAddendum(this);\n (\"production\" !== process.env.NODE_ENV ? warning(false, 'Failed propType: %s%s', error.message, addendum) : null);\n }\n }\n }\n}\n\nvar warnedPropsMutations = {};\n\n/**\n * Warn about mutating props when setting `propName` on `element`.\n *\n * @param {string} propName The string key within props that was set\n * @param {ReactElement} element\n */\nfunction warnForPropsMutation(propName, element) {\n var type = element.type;\n var elementName = typeof type === 'string' ? type : type.displayName;\n var ownerName = element._owner ?\n element._owner.getPublicInstance().constructor.displayName : null;\n\n var warningKey = propName + '|' + elementName + '|' + ownerName;\n if (warnedPropsMutations.hasOwnProperty(warningKey)) {\n return;\n }\n warnedPropsMutations[warningKey] = true;\n\n var elementInfo = '';\n if (elementName) {\n elementInfo = ' <' + elementName + ' />';\n }\n var ownerInfo = '';\n if (ownerName) {\n ownerInfo = ' The element was created by ' + ownerName + '.';\n }\n\n (\"production\" !== process.env.NODE_ENV ? warning(\n false,\n 'Don\\'t set .props.%s of the React component%s. Instead, specify the ' +\n 'correct value when initially creating the element or use ' +\n 'React.cloneElement to make a new element with updated props.%s',\n propName,\n elementInfo,\n ownerInfo\n ) : null);\n}\n\n// Inline Object.is polyfill\nfunction is(a, b) {\n if (a !== a) {\n // NaN\n return b !== b;\n }\n if (a === 0 && b === 0) {\n // +-0\n return 1 / a === 1 / b;\n }\n return a === b;\n}\n\n/**\n * Given an element, check if its props have been mutated since element\n * creation (or the last call to this function). In particular, check if any\n * new props have been added, which we can't directly catch by defining warning\n * properties on the props object.\n *\n * @param {ReactElement} element\n */\nfunction checkAndWarnForMutatedProps(element) {\n if (!element._store) {\n // Element was created using `new ReactElement` directly or with\n // `ReactElement.createElement`; skip mutation checking\n return;\n }\n\n var originalProps = element._store.originalProps;\n var props = element.props;\n\n for (var propName in props) {\n if (props.hasOwnProperty(propName)) {\n if (!originalProps.hasOwnProperty(propName) ||\n !is(originalProps[propName], props[propName])) {\n warnForPropsMutation(propName, element);\n\n // Copy over the new value so that the two props objects match again\n originalProps[propName] = props[propName];\n }\n }\n }\n}\n\n/**\n * Given an element, validate that its props follow the propTypes definition,\n * provided by the type.\n *\n * @param {ReactElement} element\n */\nfunction validatePropTypes(element) {\n if (element.type == null) {\n // This has already warned. Don't throw.\n return;\n }\n // Extract the component class from the element. Converts string types\n // to a composite class which may have propTypes.\n // TODO: Validating a string's propTypes is not decoupled from the\n // rendering target which is problematic.\n var componentClass = ReactNativeComponent.getComponentClassForElement(\n element\n );\n var name = componentClass.displayName || componentClass.name;\n if (componentClass.propTypes) {\n checkPropTypes(\n name,\n componentClass.propTypes,\n element.props,\n ReactPropTypeLocations.prop\n );\n }\n if (typeof componentClass.getDefaultProps === 'function') {\n (\"production\" !== process.env.NODE_ENV ? warning(\n componentClass.getDefaultProps.isReactClassApproved,\n 'getDefaultProps is only used on classic React.createClass ' +\n 'definitions. Use a static property named `defaultProps` instead.'\n ) : null);\n }\n}\n\nvar ReactElementValidator = {\n\n checkAndWarnForMutatedProps: checkAndWarnForMutatedProps,\n\n createElement: function(type, props, children) {\n // We warn in this case but don't throw. We expect the element creation to\n // succeed and there will likely be errors in render.\n (\"production\" !== process.env.NODE_ENV ? warning(\n type != null,\n 'React.createElement: type should not be null or undefined. It should ' +\n 'be a string (for DOM elements) or a ReactClass (for composite ' +\n 'components).'\n ) : null);\n\n var element = ReactElement.createElement.apply(this, arguments);\n\n // The result can be nullish if a mock or a custom function is used.\n // TODO: Drop this when these are no longer allowed as the type argument.\n if (element == null) {\n return element;\n }\n\n for (var i = 2; i < arguments.length; i++) {\n validateChildKeys(arguments[i], type);\n }\n\n validatePropTypes(element);\n\n return element;\n },\n\n createFactory: function(type) {\n var validatedFactory = ReactElementValidator.createElement.bind(\n null,\n type\n );\n // Legacy hook TODO: Warn if this is accessed\n validatedFactory.type = type;\n\n if (\"production\" !== process.env.NODE_ENV) {\n try {\n Object.defineProperty(\n validatedFactory,\n 'type',\n {\n enumerable: false,\n get: function() {\n (\"production\" !== process.env.NODE_ENV ? warning(\n false,\n 'Factory.type is deprecated. Access the class directly ' +\n 'before passing it to createFactory.'\n ) : null);\n Object.defineProperty(this, 'type', {\n value: type\n });\n return type;\n }\n }\n );\n } catch (x) {\n // IE will fail on defineProperty (es5-shim/sham too)\n }\n }\n\n\n return validatedFactory;\n },\n\n cloneElement: function(element, props, children) {\n var newElement = ReactElement.cloneElement.apply(this, arguments);\n for (var i = 2; i < arguments.length; i++) {\n validateChildKeys(arguments[i], newElement.type);\n }\n validatePropTypes(newElement);\n return newElement;\n }\n\n};\n\nmodule.exports = ReactElementValidator;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactElementValidator.js\n ** module id = 84\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ReactElementValidator.js?");
|
||
|
||
/***/ },
|
||
/* 85 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/* WEBPACK VAR INJECTION */(function(process) {/**\n * Copyright 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 ReactFragment\n*/\n\n'use strict';\n\nvar ReactElement = __webpack_require__(79);\n\nvar warning = __webpack_require__(82);\n\n/**\n * We used to allow keyed objects to serve as a collection of ReactElements,\n * or nested sets. This allowed us a way to explicitly key a set a fragment of\n * components. This is now being replaced with an opaque data structure.\n * The upgrade path is to call React.addons.createFragment({ key: value }) to\n * create a keyed fragment. The resulting data structure is opaque, for now.\n */\n\nif (\"production\" !== process.env.NODE_ENV) {\n var fragmentKey = '_reactFragment';\n var didWarnKey = '_reactDidWarn';\n var canWarnForReactFragment = false;\n\n try {\n // Feature test. Don't even try to issue this warning if we can't use\n // enumerable: false.\n\n var dummy = function() {\n return 1;\n };\n\n Object.defineProperty(\n {},\n fragmentKey,\n {enumerable: false, value: true}\n );\n\n Object.defineProperty(\n {},\n 'key',\n {enumerable: true, get: dummy}\n );\n\n canWarnForReactFragment = true;\n } catch (x) { }\n\n var proxyPropertyAccessWithWarning = function(obj, key) {\n Object.defineProperty(obj, key, {\n enumerable: true,\n get: function() {\n (\"production\" !== process.env.NODE_ENV ? warning(\n this[didWarnKey],\n 'A ReactFragment is an opaque type. Accessing any of its ' +\n 'properties is deprecated. Pass it to one of the React.Children ' +\n 'helpers.'\n ) : null);\n this[didWarnKey] = true;\n return this[fragmentKey][key];\n },\n set: function(value) {\n (\"production\" !== process.env.NODE_ENV ? warning(\n this[didWarnKey],\n 'A ReactFragment is an immutable opaque type. Mutating its ' +\n 'properties is deprecated.'\n ) : null);\n this[didWarnKey] = true;\n this[fragmentKey][key] = value;\n }\n });\n };\n\n var issuedWarnings = {};\n\n var didWarnForFragment = function(fragment) {\n // We use the keys and the type of the value as a heuristic to dedupe the\n // warning to avoid spamming too much.\n var fragmentCacheKey = '';\n for (var key in fragment) {\n fragmentCacheKey += key + ':' + (typeof fragment[key]) + ',';\n }\n var alreadyWarnedOnce = !!issuedWarnings[fragmentCacheKey];\n issuedWarnings[fragmentCacheKey] = true;\n return alreadyWarnedOnce;\n };\n}\n\nvar ReactFragment = {\n // Wrap a keyed object in an opaque proxy that warns you if you access any\n // of its properties.\n create: function(object) {\n if (\"production\" !== process.env.NODE_ENV) {\n if (typeof object !== 'object' || !object || Array.isArray(object)) {\n (\"production\" !== process.env.NODE_ENV ? warning(\n false,\n 'React.addons.createFragment only accepts a single object.',\n object\n ) : null);\n return object;\n }\n if (ReactElement.isValidElement(object)) {\n (\"production\" !== process.env.NODE_ENV ? warning(\n false,\n 'React.addons.createFragment does not accept a ReactElement ' +\n 'without a wrapper object.'\n ) : null);\n return object;\n }\n if (canWarnForReactFragment) {\n var proxy = {};\n Object.defineProperty(proxy, fragmentKey, {\n enumerable: false,\n value: object\n });\n Object.defineProperty(proxy, didWarnKey, {\n writable: true,\n enumerable: false,\n value: false\n });\n for (var key in object) {\n proxyPropertyAccessWithWarning(proxy, key);\n }\n Object.preventExtensions(proxy);\n return proxy;\n }\n }\n return object;\n },\n // Extract the original keyed object from the fragment opaque type. Warn if\n // a plain object is passed here.\n extract: function(fragment) {\n if (\"production\" !== process.env.NODE_ENV) {\n if (canWarnForReactFragment) {\n if (!fragment[fragmentKey]) {\n (\"production\" !== process.env.NODE_ENV ? warning(\n didWarnForFragment(fragment),\n 'Any use of a keyed object should be wrapped in ' +\n 'React.addons.createFragment(object) before being passed as a ' +\n 'child.'\n ) : null);\n return fragment;\n }\n return fragment[fragmentKey];\n }\n }\n return fragment;\n },\n // Check if this is a fragment and if so, extract the keyed object. If it\n // is a fragment-like object, warn that it should be wrapped. Ignore if we\n // can't determine what kind of object this is.\n extractIfFragment: function(fragment) {\n if (\"production\" !== process.env.NODE_ENV) {\n if (canWarnForReactFragment) {\n // If it is the opaque type, return the keyed object.\n if (fragment[fragmentKey]) {\n return fragment[fragmentKey];\n }\n // Otherwise, check each property if it has an element, if it does\n // it is probably meant as a fragment, so we can warn early. Defer,\n // the warning to extract.\n for (var key in fragment) {\n if (fragment.hasOwnProperty(key) &&\n ReactElement.isValidElement(fragment[key])) {\n // This looks like a fragment object, we should provide an\n // early warning.\n return ReactFragment.extract(fragment);\n }\n }\n }\n }\n return fragment;\n }\n};\n\nmodule.exports = ReactFragment;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactFragment.js\n ** module id = 85\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ReactFragment.js?");
|
||
|
||
/***/ },
|
||
/* 86 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\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 ReactPropTypeLocations\n */\n\n'use strict';\n\nvar keyMirror = __webpack_require__(67);\n\nvar ReactPropTypeLocations = keyMirror({\n prop: null,\n context: null,\n childContext: null\n});\n\nmodule.exports = ReactPropTypeLocations;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactPropTypeLocations.js\n ** module id = 86\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ReactPropTypeLocations.js?");
|
||
|
||
/***/ },
|
||
/* 87 */
|
||
/***/ 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 ReactPropTypeLocationNames\n */\n\n'use strict';\n\nvar ReactPropTypeLocationNames = {};\n\nif (\"production\" !== process.env.NODE_ENV) {\n ReactPropTypeLocationNames = {\n prop: 'prop',\n context: 'context',\n childContext: 'child context'\n };\n}\n\nmodule.exports = ReactPropTypeLocationNames;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactPropTypeLocationNames.js\n ** module id = 87\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ReactPropTypeLocationNames.js?");
|
||
|
||
/***/ },
|
||
/* 88 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/* WEBPACK VAR INJECTION */(function(process) {/**\n * Copyright 2014-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 ReactNativeComponent\n */\n\n'use strict';\n\nvar assign = __webpack_require__(75);\nvar invariant = __webpack_require__(64);\n\nvar autoGenerateWrapperClass = null;\nvar genericComponentClass = null;\n// This registry keeps track of wrapper classes around native tags\nvar tagToComponentClass = {};\nvar textComponentClass = null;\n\nvar ReactNativeComponentInjection = {\n // This accepts a class that receives the tag string. This is a catch all\n // that can render any kind of tag.\n injectGenericComponentClass: function(componentClass) {\n genericComponentClass = componentClass;\n },\n // This accepts a text component class that takes the text string to be\n // rendered as props.\n injectTextComponentClass: function(componentClass) {\n textComponentClass = componentClass;\n },\n // This accepts a keyed object with classes as values. Each key represents a\n // tag. That particular tag will use this class instead of the generic one.\n injectComponentClasses: function(componentClasses) {\n assign(tagToComponentClass, componentClasses);\n },\n // Temporary hack since we expect DOM refs to behave like composites,\n // for this release.\n injectAutoWrapper: function(wrapperFactory) {\n autoGenerateWrapperClass = wrapperFactory;\n }\n};\n\n/**\n * Get a composite component wrapper class for a specific tag.\n *\n * @param {ReactElement} element The tag for which to get the class.\n * @return {function} The React class constructor function.\n */\nfunction getComponentClassForElement(element) {\n if (typeof element.type === 'function') {\n return element.type;\n }\n var tag = element.type;\n var componentClass = tagToComponentClass[tag];\n if (componentClass == null) {\n tagToComponentClass[tag] = componentClass = autoGenerateWrapperClass(tag);\n }\n return componentClass;\n}\n\n/**\n * Get a native internal component class for a specific tag.\n *\n * @param {ReactElement} element The element to create.\n * @return {function} The internal class constructor function.\n */\nfunction createInternalComponent(element) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n genericComponentClass,\n 'There is no registered component for the tag %s',\n element.type\n ) : invariant(genericComponentClass));\n return new genericComponentClass(element.type, element.props);\n}\n\n/**\n * @param {ReactText} text\n * @return {ReactComponent}\n */\nfunction createInstanceForText(text) {\n return new textComponentClass(text);\n}\n\n/**\n * @param {ReactComponent} component\n * @return {boolean}\n */\nfunction isTextComponent(component) {\n return component instanceof textComponentClass;\n}\n\nvar ReactNativeComponent = {\n getComponentClassForElement: getComponentClassForElement,\n createInternalComponent: createInternalComponent,\n createInstanceForText: createInstanceForText,\n isTextComponent: isTextComponent,\n injection: ReactNativeComponentInjection\n};\n\nmodule.exports = ReactNativeComponent;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactNativeComponent.js\n ** module id = 88\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ReactNativeComponent.js?");
|
||
|
||
/***/ },
|
||
/* 89 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("/**\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 getIteratorFn\n * @typechecks static-only\n */\n\n'use strict';\n\n/* global Symbol */\nvar ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;\nvar FAUX_ITERATOR_SYMBOL = '@@iterator'; // Before Symbol spec.\n\n/**\n * Returns the iterator method function contained on the iterable object.\n *\n * Be sure to invoke the function with the iterable as context:\n *\n * var iteratorFn = getIteratorFn(myIterable);\n * if (iteratorFn) {\n * var iterator = iteratorFn.call(myIterable);\n * ...\n * }\n *\n * @param {?object} maybeIterable\n * @return {?function}\n */\nfunction getIteratorFn(maybeIterable) {\n var iteratorFn = maybeIterable && (\n (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL])\n );\n if (typeof iteratorFn === 'function') {\n return iteratorFn;\n }\n}\n\nmodule.exports = getIteratorFn;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/getIteratorFn.js\n ** module id = 89\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/getIteratorFn.js?");
|
||
|
||
/***/ },
|
||
/* 90 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/* WEBPACK VAR INJECTION */(function(process) {/**\n * Copyright 2014-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 ReactEmptyComponent\n */\n\n'use strict';\n\nvar ReactElement = __webpack_require__(79);\nvar ReactInstanceMap = __webpack_require__(91);\n\nvar invariant = __webpack_require__(64);\n\nvar component;\n// This registry keeps track of the React IDs of the components that rendered to\n// `null` (in reality a placeholder such as `noscript`)\nvar nullComponentIDsRegistry = {};\n\nvar ReactEmptyComponentInjection = {\n injectEmptyComponent: function(emptyComponent) {\n component = ReactElement.createFactory(emptyComponent);\n }\n};\n\nvar ReactEmptyComponentType = function() {};\nReactEmptyComponentType.prototype.componentDidMount = function() {\n var internalInstance = ReactInstanceMap.get(this);\n // TODO: Make sure we run these methods in the correct order, we shouldn't\n // need this check. We're going to assume if we're here it means we ran\n // componentWillUnmount already so there is no internal instance (it gets\n // removed as part of the unmounting process).\n if (!internalInstance) {\n return;\n }\n registerNullComponentID(internalInstance._rootNodeID);\n};\nReactEmptyComponentType.prototype.componentWillUnmount = function() {\n var internalInstance = ReactInstanceMap.get(this);\n // TODO: Get rid of this check. See TODO in componentDidMount.\n if (!internalInstance) {\n return;\n }\n deregisterNullComponentID(internalInstance._rootNodeID);\n};\nReactEmptyComponentType.prototype.render = function() {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n component,\n 'Trying to return null from a render, but no null placeholder component ' +\n 'was injected.'\n ) : invariant(component));\n return component();\n};\n\nvar emptyElement = ReactElement.createElement(ReactEmptyComponentType);\n\n/**\n * Mark the component as having rendered to null.\n * @param {string} id Component's `_rootNodeID`.\n */\nfunction registerNullComponentID(id) {\n nullComponentIDsRegistry[id] = true;\n}\n\n/**\n * Unmark the component as having rendered to null: it renders to something now.\n * @param {string} id Component's `_rootNodeID`.\n */\nfunction deregisterNullComponentID(id) {\n delete nullComponentIDsRegistry[id];\n}\n\n/**\n * @param {string} id Component's `_rootNodeID`.\n * @return {boolean} True if the component is rendered to null.\n */\nfunction isNullComponentID(id) {\n return !!nullComponentIDsRegistry[id];\n}\n\nvar ReactEmptyComponent = {\n emptyElement: emptyElement,\n injection: ReactEmptyComponentInjection,\n isNullComponentID: isNullComponentID\n};\n\nmodule.exports = ReactEmptyComponent;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactEmptyComponent.js\n ** module id = 90\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ReactEmptyComponent.js?");
|
||
|
||
/***/ },
|
||
/* 91 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("/**\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 ReactInstanceMap\n */\n\n'use strict';\n\n/**\n * `ReactInstanceMap` maintains a mapping from a public facing stateful\n * instance (key) and the internal representation (value). This allows public\n * methods to accept the user facing instance as an argument and map them back\n * to internal methods.\n */\n\n// TODO: Replace this with ES6: var ReactInstanceMap = new Map();\nvar ReactInstanceMap = {\n\n /**\n * This API should be called `delete` but we'd have to make sure to always\n * transform these to strings for IE support. When this transform is fully\n * supported we can rename it.\n */\n remove: function(key) {\n key._reactInternalInstance = undefined;\n },\n\n get: function(key) {\n return key._reactInternalInstance;\n },\n\n has: function(key) {\n return key._reactInternalInstance !== undefined;\n },\n\n set: function(key, value) {\n key._reactInternalInstance = value;\n }\n\n};\n\nmodule.exports = ReactInstanceMap;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactInstanceMap.js\n ** module id = 91\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ReactInstanceMap.js?");
|
||
|
||
/***/ },
|
||
/* 92 */
|
||
/***/ 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 ReactInstanceHandles\n * @typechecks static-only\n */\n\n'use strict';\n\nvar ReactRootIndex = __webpack_require__(93);\n\nvar invariant = __webpack_require__(64);\n\nvar SEPARATOR = '.';\nvar SEPARATOR_LENGTH = SEPARATOR.length;\n\n/**\n * Maximum depth of traversals before we consider the possibility of a bad ID.\n */\nvar MAX_TREE_DEPTH = 100;\n\n/**\n * Creates a DOM ID prefix to use when mounting React components.\n *\n * @param {number} index A unique integer\n * @return {string} React root ID.\n * @internal\n */\nfunction getReactRootIDString(index) {\n return SEPARATOR + index.toString(36);\n}\n\n/**\n * Checks if a character in the supplied ID is a separator or the end.\n *\n * @param {string} id A React DOM ID.\n * @param {number} index Index of the character to check.\n * @return {boolean} True if the character is a separator or end of the ID.\n * @private\n */\nfunction isBoundary(id, index) {\n return id.charAt(index) === SEPARATOR || index === id.length;\n}\n\n/**\n * Checks if the supplied string is a valid React DOM ID.\n *\n * @param {string} id A React DOM ID, maybe.\n * @return {boolean} True if the string is a valid React DOM ID.\n * @private\n */\nfunction isValidID(id) {\n return id === '' || (\n id.charAt(0) === SEPARATOR && id.charAt(id.length - 1) !== SEPARATOR\n );\n}\n\n/**\n * Checks if the first ID is an ancestor of or equal to the second ID.\n *\n * @param {string} ancestorID\n * @param {string} descendantID\n * @return {boolean} True if `ancestorID` is an ancestor of `descendantID`.\n * @internal\n */\nfunction isAncestorIDOf(ancestorID, descendantID) {\n return (\n descendantID.indexOf(ancestorID) === 0 &&\n isBoundary(descendantID, ancestorID.length)\n );\n}\n\n/**\n * Gets the parent ID of the supplied React DOM ID, `id`.\n *\n * @param {string} id ID of a component.\n * @return {string} ID of the parent, or an empty string.\n * @private\n */\nfunction getParentID(id) {\n return id ? id.substr(0, id.lastIndexOf(SEPARATOR)) : '';\n}\n\n/**\n * Gets the next DOM ID on the tree path from the supplied `ancestorID` to the\n * supplied `destinationID`. If they are equal, the ID is returned.\n *\n * @param {string} ancestorID ID of an ancestor node of `destinationID`.\n * @param {string} destinationID ID of the destination node.\n * @return {string} Next ID on the path from `ancestorID` to `destinationID`.\n * @private\n */\nfunction getNextDescendantID(ancestorID, destinationID) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n isValidID(ancestorID) && isValidID(destinationID),\n 'getNextDescendantID(%s, %s): Received an invalid React DOM ID.',\n ancestorID,\n destinationID\n ) : invariant(isValidID(ancestorID) && isValidID(destinationID)));\n (\"production\" !== process.env.NODE_ENV ? invariant(\n isAncestorIDOf(ancestorID, destinationID),\n 'getNextDescendantID(...): React has made an invalid assumption about ' +\n 'the DOM hierarchy. Expected `%s` to be an ancestor of `%s`.',\n ancestorID,\n destinationID\n ) : invariant(isAncestorIDOf(ancestorID, destinationID)));\n if (ancestorID === destinationID) {\n return ancestorID;\n }\n // Skip over the ancestor and the immediate separator. Traverse until we hit\n // another separator or we reach the end of `destinationID`.\n var start = ancestorID.length + SEPARATOR_LENGTH;\n var i;\n for (i = start; i < destinationID.length; i++) {\n if (isBoundary(destinationID, i)) {\n break;\n }\n }\n return destinationID.substr(0, i);\n}\n\n/**\n * Gets the nearest common ancestor ID of two IDs.\n *\n * Using this ID scheme, the nearest common ancestor ID is the longest common\n * prefix of the two IDs that immediately preceded a \"marker\" in both strings.\n *\n * @param {string} oneID\n * @param {string} twoID\n * @return {string} Nearest common ancestor ID, or the empty string if none.\n * @private\n */\nfunction getFirstCommonAncestorID(oneID, twoID) {\n var minLength = Math.min(oneID.length, twoID.length);\n if (minLength === 0) {\n return '';\n }\n var lastCommonMarkerIndex = 0;\n // Use `<=` to traverse until the \"EOL\" of the shorter string.\n for (var i = 0; i <= minLength; i++) {\n if (isBoundary(oneID, i) && isBoundary(twoID, i)) {\n lastCommonMarkerIndex = i;\n } else if (oneID.charAt(i) !== twoID.charAt(i)) {\n break;\n }\n }\n var longestCommonID = oneID.substr(0, lastCommonMarkerIndex);\n (\"production\" !== process.env.NODE_ENV ? invariant(\n isValidID(longestCommonID),\n 'getFirstCommonAncestorID(%s, %s): Expected a valid React DOM ID: %s',\n oneID,\n twoID,\n longestCommonID\n ) : invariant(isValidID(longestCommonID)));\n return longestCommonID;\n}\n\n/**\n * Traverses the parent path between two IDs (either up or down). The IDs must\n * not be the same, and there must exist a parent path between them. If the\n * callback returns `false`, traversal is stopped.\n *\n * @param {?string} start ID at which to start traversal.\n * @param {?string} stop ID at which to end traversal.\n * @param {function} cb Callback to invoke each ID with.\n * @param {?boolean} skipFirst Whether or not to skip the first node.\n * @param {?boolean} skipLast Whether or not to skip the last node.\n * @private\n */\nfunction traverseParentPath(start, stop, cb, arg, skipFirst, skipLast) {\n start = start || '';\n stop = stop || '';\n (\"production\" !== process.env.NODE_ENV ? invariant(\n start !== stop,\n 'traverseParentPath(...): Cannot traverse from and to the same ID, `%s`.',\n start\n ) : invariant(start !== stop));\n var traverseUp = isAncestorIDOf(stop, start);\n (\"production\" !== process.env.NODE_ENV ? invariant(\n traverseUp || isAncestorIDOf(start, stop),\n 'traverseParentPath(%s, %s, ...): Cannot traverse from two IDs that do ' +\n 'not have a parent path.',\n start,\n stop\n ) : invariant(traverseUp || isAncestorIDOf(start, stop)));\n // Traverse from `start` to `stop` one depth at a time.\n var depth = 0;\n var traverse = traverseUp ? getParentID : getNextDescendantID;\n for (var id = start; /* until break */; id = traverse(id, stop)) {\n var ret;\n if ((!skipFirst || id !== start) && (!skipLast || id !== stop)) {\n ret = cb(id, traverseUp, arg);\n }\n if (ret === false || id === stop) {\n // Only break //after// visiting `stop`.\n break;\n }\n (\"production\" !== process.env.NODE_ENV ? invariant(\n depth++ < MAX_TREE_DEPTH,\n 'traverseParentPath(%s, %s, ...): Detected an infinite loop while ' +\n 'traversing the React DOM ID tree. This may be due to malformed IDs: %s',\n start, stop\n ) : invariant(depth++ < MAX_TREE_DEPTH));\n }\n}\n\n/**\n * Manages the IDs assigned to DOM representations of React components. This\n * uses a specific scheme in order to traverse the DOM efficiently (e.g. in\n * order to simulate events).\n *\n * @internal\n */\nvar ReactInstanceHandles = {\n\n /**\n * Constructs a React root ID\n * @return {string} A React root ID.\n */\n createReactRootID: function() {\n return getReactRootIDString(ReactRootIndex.createReactRootIndex());\n },\n\n /**\n * Constructs a React ID by joining a root ID with a name.\n *\n * @param {string} rootID Root ID of a parent component.\n * @param {string} name A component's name (as flattened children).\n * @return {string} A React ID.\n * @internal\n */\n createReactID: function(rootID, name) {\n return rootID + name;\n },\n\n /**\n * Gets the DOM ID of the React component that is the root of the tree that\n * contains the React component with the supplied DOM ID.\n *\n * @param {string} id DOM ID of a React component.\n * @return {?string} DOM ID of the React component that is the root.\n * @internal\n */\n getReactRootIDFromNodeID: function(id) {\n if (id && id.charAt(0) === SEPARATOR && id.length > 1) {\n var index = id.indexOf(SEPARATOR, 1);\n return index > -1 ? id.substr(0, index) : id;\n }\n return null;\n },\n\n /**\n * Traverses the ID hierarchy and invokes the supplied `cb` on any IDs that\n * should would receive a `mouseEnter` or `mouseLeave` event.\n *\n * NOTE: Does not invoke the callback on the nearest common ancestor because\n * nothing \"entered\" or \"left\" that element.\n *\n * @param {string} leaveID ID being left.\n * @param {string} enterID ID being entered.\n * @param {function} cb Callback to invoke on each entered/left ID.\n * @param {*} upArg Argument to invoke the callback with on left IDs.\n * @param {*} downArg Argument to invoke the callback with on entered IDs.\n * @internal\n */\n traverseEnterLeave: function(leaveID, enterID, cb, upArg, downArg) {\n var ancestorID = getFirstCommonAncestorID(leaveID, enterID);\n if (ancestorID !== leaveID) {\n traverseParentPath(leaveID, ancestorID, cb, upArg, false, true);\n }\n if (ancestorID !== enterID) {\n traverseParentPath(ancestorID, enterID, cb, downArg, true, false);\n }\n },\n\n /**\n * Simulates the traversal of a two-phase, capture/bubble event dispatch.\n *\n * NOTE: This traversal happens on IDs without touching the DOM.\n *\n * @param {string} targetID ID of the target node.\n * @param {function} cb Callback to invoke.\n * @param {*} arg Argument to invoke the callback with.\n * @internal\n */\n traverseTwoPhase: function(targetID, cb, arg) {\n if (targetID) {\n traverseParentPath('', targetID, cb, arg, true, false);\n traverseParentPath(targetID, '', cb, arg, false, true);\n }\n },\n\n /**\n * Traverse a node ID, calling the supplied `cb` for each ancestor ID. For\n * example, passing `.0.$row-0.1` would result in `cb` getting called\n * with `.0`, `.0.$row-0`, and `.0.$row-0.1`.\n *\n * NOTE: This traversal happens on IDs without touching the DOM.\n *\n * @param {string} targetID ID of the target node.\n * @param {function} cb Callback to invoke.\n * @param {*} arg Argument to invoke the callback with.\n * @internal\n */\n traverseAncestors: function(targetID, cb, arg) {\n traverseParentPath('', targetID, cb, arg, true, false);\n },\n\n /**\n * Exposed for unit testing.\n * @private\n */\n _getFirstCommonAncestorID: getFirstCommonAncestorID,\n\n /**\n * Exposed for unit testing.\n * @private\n */\n _getNextDescendantID: getNextDescendantID,\n\n isAncestorIDOf: isAncestorIDOf,\n\n SEPARATOR: SEPARATOR\n\n};\n\nmodule.exports = ReactInstanceHandles;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactInstanceHandles.js\n ** module id = 92\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ReactInstanceHandles.js?");
|
||
|
||
/***/ },
|
||
/* 93 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("/**\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 ReactRootIndex\n * @typechecks\n */\n\n'use strict';\n\nvar ReactRootIndexInjection = {\n /**\n * @param {function} _createReactRootIndex\n */\n injectCreateReactRootIndex: function(_createReactRootIndex) {\n ReactRootIndex.createReactRootIndex = _createReactRootIndex;\n }\n};\n\nvar ReactRootIndex = {\n createReactRootIndex: null,\n injection: ReactRootIndexInjection\n};\n\nmodule.exports = ReactRootIndex;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactRootIndex.js\n ** module id = 93\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ReactRootIndex.js?");
|
||
|
||
/***/ },
|
||
/* 94 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\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 ReactMarkupChecksum\n */\n\n'use strict';\n\nvar adler32 = __webpack_require__(95);\n\nvar ReactMarkupChecksum = {\n CHECKSUM_ATTR_NAME: 'data-react-checksum',\n\n /**\n * @param {string} markup Markup string\n * @return {string} Markup string with checksum attribute attached\n */\n addChecksumToMarkup: function(markup) {\n var checksum = adler32(markup);\n return markup.replace(\n '>',\n ' ' + ReactMarkupChecksum.CHECKSUM_ATTR_NAME + '=\"' + checksum + '\">'\n );\n },\n\n /**\n * @param {string} markup to use\n * @param {DOMElement} element root React element\n * @returns {boolean} whether or not the markup is the same\n */\n canReuseMarkup: function(markup, element) {\n var existingChecksum = element.getAttribute(\n ReactMarkupChecksum.CHECKSUM_ATTR_NAME\n );\n existingChecksum = existingChecksum && parseInt(existingChecksum, 10);\n var markupChecksum = adler32(markup);\n return markupChecksum === existingChecksum;\n }\n};\n\nmodule.exports = ReactMarkupChecksum;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactMarkupChecksum.js\n ** module id = 94\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ReactMarkupChecksum.js?");
|
||
|
||
/***/ },
|
||
/* 95 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("/**\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 adler32\n */\n\n/* jslint bitwise:true */\n\n'use strict';\n\nvar MOD = 65521;\n\n// This is a clean-room implementation of adler32 designed for detecting\n// if markup is not what we expect it to be. It does not need to be\n// cryptographically strong, only reasonably good at detecting if markup\n// generated on the server is different than that on the client.\nfunction adler32(data) {\n var a = 1;\n var b = 0;\n for (var i = 0; i < data.length; i++) {\n a = (a + data.charCodeAt(i)) % MOD;\n b = (b + a) % MOD;\n }\n return a | (b << 16);\n}\n\nmodule.exports = adler32;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/adler32.js\n ** module id = 95\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/adler32.js?");
|
||
|
||
/***/ },
|
||
/* 96 */
|
||
/***/ 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 ReactPerf\n * @typechecks static-only\n */\n\n'use strict';\n\n/**\n * ReactPerf is a general AOP system designed to measure performance. This\n * module only has the hooks: see ReactDefaultPerf for the analysis tool.\n */\nvar ReactPerf = {\n /**\n * Boolean to enable/disable measurement. Set to false by default to prevent\n * accidental logging and perf loss.\n */\n enableMeasure: false,\n\n /**\n * Holds onto the measure function in use. By default, don't measure\n * anything, but we'll override this if we inject a measure function.\n */\n storedMeasure: _noMeasure,\n\n /**\n * @param {object} object\n * @param {string} objectName\n * @param {object<string>} methodNames\n */\n measureMethods: function(object, objectName, methodNames) {\n if (\"production\" !== process.env.NODE_ENV) {\n for (var key in methodNames) {\n if (!methodNames.hasOwnProperty(key)) {\n continue;\n }\n object[key] = ReactPerf.measure(\n objectName,\n methodNames[key],\n object[key]\n );\n }\n }\n },\n\n /**\n * Use this to wrap methods you want to measure. Zero overhead in production.\n *\n * @param {string} objName\n * @param {string} fnName\n * @param {function} func\n * @return {function}\n */\n measure: function(objName, fnName, func) {\n if (\"production\" !== process.env.NODE_ENV) {\n var measuredFunc = null;\n var wrapper = function() {\n if (ReactPerf.enableMeasure) {\n if (!measuredFunc) {\n measuredFunc = ReactPerf.storedMeasure(objName, fnName, func);\n }\n return measuredFunc.apply(this, arguments);\n }\n return func.apply(this, arguments);\n };\n wrapper.displayName = objName + '_' + fnName;\n return wrapper;\n }\n return func;\n },\n\n injection: {\n /**\n * @param {function} measure\n */\n injectMeasure: function(measure) {\n ReactPerf.storedMeasure = measure;\n }\n }\n};\n\n/**\n * Simply passes through the measured function, without measuring it.\n *\n * @param {string} objName\n * @param {string} fnName\n * @param {function} func\n * @return {function}\n */\nfunction _noMeasure(objName, fnName, func) {\n return func;\n}\n\nmodule.exports = ReactPerf;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactPerf.js\n ** module id = 96\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ReactPerf.js?");
|
||
|
||
/***/ },
|
||
/* 97 */
|
||
/***/ 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 ReactReconciler\n */\n\n'use strict';\n\nvar ReactRef = __webpack_require__(98);\nvar ReactElementValidator = __webpack_require__(84);\n\n/**\n * Helper to call ReactRef.attachRefs with this composite component, split out\n * to avoid allocations in the transaction mount-ready queue.\n */\nfunction attachRefs() {\n ReactRef.attachRefs(this, this._currentElement);\n}\n\nvar ReactReconciler = {\n\n /**\n * Initializes the component, renders markup, and registers event listeners.\n *\n * @param {ReactComponent} internalInstance\n * @param {string} rootID DOM ID of the root node.\n * @param {ReactReconcileTransaction|ReactServerRenderingTransaction} transaction\n * @return {?string} Rendered markup to be inserted into the DOM.\n * @final\n * @internal\n */\n mountComponent: function(internalInstance, rootID, transaction, context) {\n var markup = internalInstance.mountComponent(rootID, transaction, context);\n if (\"production\" !== process.env.NODE_ENV) {\n ReactElementValidator.checkAndWarnForMutatedProps(\n internalInstance._currentElement\n );\n }\n transaction.getReactMountReady().enqueue(attachRefs, internalInstance);\n return markup;\n },\n\n /**\n * Releases any resources allocated by `mountComponent`.\n *\n * @final\n * @internal\n */\n unmountComponent: function(internalInstance) {\n ReactRef.detachRefs(internalInstance, internalInstance._currentElement);\n internalInstance.unmountComponent();\n },\n\n /**\n * Update a component using a new element.\n *\n * @param {ReactComponent} internalInstance\n * @param {ReactElement} nextElement\n * @param {ReactReconcileTransaction} transaction\n * @param {object} context\n * @internal\n */\n receiveComponent: function(\n internalInstance, nextElement, transaction, context\n ) {\n var prevElement = internalInstance._currentElement;\n\n if (nextElement === prevElement && nextElement._owner != null) {\n // Since elements are immutable after the owner is rendered,\n // we can do a cheap identity compare here to determine if this is a\n // superfluous reconcile. It's possible for state to be mutable but such\n // change should trigger an update of the owner which would recreate\n // the element. We explicitly check for the existence of an owner since\n // it's possible for an element created outside a composite to be\n // deeply mutated and reused.\n return;\n }\n\n if (\"production\" !== process.env.NODE_ENV) {\n ReactElementValidator.checkAndWarnForMutatedProps(nextElement);\n }\n\n var refsChanged = ReactRef.shouldUpdateRefs(\n prevElement,\n nextElement\n );\n\n if (refsChanged) {\n ReactRef.detachRefs(internalInstance, prevElement);\n }\n\n internalInstance.receiveComponent(nextElement, transaction, context);\n\n if (refsChanged) {\n transaction.getReactMountReady().enqueue(attachRefs, internalInstance);\n }\n },\n\n /**\n * Flush any dirty changes in a component.\n *\n * @param {ReactComponent} internalInstance\n * @param {ReactReconcileTransaction} transaction\n * @internal\n */\n performUpdateIfNecessary: function(\n internalInstance,\n transaction\n ) {\n internalInstance.performUpdateIfNecessary(transaction);\n }\n\n};\n\nmodule.exports = ReactReconciler;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactReconciler.js\n ** module id = 97\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ReactReconciler.js?");
|
||
|
||
/***/ },
|
||
/* 98 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\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 ReactRef\n */\n\n'use strict';\n\nvar ReactOwner = __webpack_require__(99);\n\nvar ReactRef = {};\n\nfunction attachRef(ref, component, owner) {\n if (typeof ref === 'function') {\n ref(component.getPublicInstance());\n } else {\n // Legacy ref\n ReactOwner.addComponentAsRefTo(component, ref, owner);\n }\n}\n\nfunction detachRef(ref, component, owner) {\n if (typeof ref === 'function') {\n ref(null);\n } else {\n // Legacy ref\n ReactOwner.removeComponentAsRefFrom(component, ref, owner);\n }\n}\n\nReactRef.attachRefs = function(instance, element) {\n var ref = element.ref;\n if (ref != null) {\n attachRef(ref, instance, element._owner);\n }\n};\n\nReactRef.shouldUpdateRefs = function(prevElement, nextElement) {\n // If either the owner or a `ref` has changed, make sure the newest owner\n // has stored a reference to `this`, and the previous owner (if different)\n // has forgotten the reference to `this`. We use the element instead\n // of the public this.props because the post processing cannot determine\n // a ref. The ref conceptually lives on the element.\n\n // TODO: Should this even be possible? The owner cannot change because\n // it's forbidden by shouldUpdateReactComponent. The ref can change\n // if you swap the keys of but not the refs. Reconsider where this check\n // is made. It probably belongs where the key checking and\n // instantiateReactComponent is done.\n\n return (\n nextElement._owner !== prevElement._owner ||\n nextElement.ref !== prevElement.ref\n );\n};\n\nReactRef.detachRefs = function(instance, element) {\n var ref = element.ref;\n if (ref != null) {\n detachRef(ref, instance, element._owner);\n }\n};\n\nmodule.exports = ReactRef;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactRef.js\n ** module id = 98\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ReactRef.js?");
|
||
|
||
/***/ },
|
||
/* 99 */
|
||
/***/ 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 ReactOwner\n */\n\n'use strict';\n\nvar invariant = __webpack_require__(64);\n\n/**\n * ReactOwners are capable of storing references to owned components.\n *\n * All components are capable of //being// referenced by owner components, but\n * only ReactOwner components are capable of //referencing// owned components.\n * The named reference is known as a \"ref\".\n *\n * Refs are available when mounted and updated during reconciliation.\n *\n * var MyComponent = React.createClass({\n * render: function() {\n * return (\n * <div onClick={this.handleClick}>\n * <CustomComponent ref=\"custom\" />\n * </div>\n * );\n * },\n * handleClick: function() {\n * this.refs.custom.handleClick();\n * },\n * componentDidMount: function() {\n * this.refs.custom.initialize();\n * }\n * });\n *\n * Refs should rarely be used. When refs are used, they should only be done to\n * control data that is not handled by React's data flow.\n *\n * @class ReactOwner\n */\nvar ReactOwner = {\n\n /**\n * @param {?object} object\n * @return {boolean} True if `object` is a valid owner.\n * @final\n */\n isValidOwner: function(object) {\n return !!(\n (object &&\n typeof object.attachRef === 'function' && typeof object.detachRef === 'function')\n );\n },\n\n /**\n * Adds a component by ref to an owner component.\n *\n * @param {ReactComponent} component Component to reference.\n * @param {string} ref Name by which to refer to the component.\n * @param {ReactOwner} owner Component on which to record the ref.\n * @final\n * @internal\n */\n addComponentAsRefTo: function(component, ref, owner) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n ReactOwner.isValidOwner(owner),\n 'addComponentAsRefTo(...): Only a ReactOwner can have refs. This ' +\n 'usually means that you\\'re trying to add a ref to a component that ' +\n 'doesn\\'t have an owner (that is, was not created inside of another ' +\n 'component\\'s `render` method). Try rendering this component inside of ' +\n 'a new top-level component which will hold the ref.'\n ) : invariant(ReactOwner.isValidOwner(owner)));\n owner.attachRef(ref, component);\n },\n\n /**\n * Removes a component by ref from an owner component.\n *\n * @param {ReactComponent} component Component to dereference.\n * @param {string} ref Name of the ref to remove.\n * @param {ReactOwner} owner Component on which the ref is recorded.\n * @final\n * @internal\n */\n removeComponentAsRefFrom: function(component, ref, owner) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n ReactOwner.isValidOwner(owner),\n 'removeComponentAsRefFrom(...): Only a ReactOwner can have refs. This ' +\n 'usually means that you\\'re trying to remove a ref to a component that ' +\n 'doesn\\'t have an owner (that is, was not created inside of another ' +\n 'component\\'s `render` method). Try rendering this component inside of ' +\n 'a new top-level component which will hold the ref.'\n ) : invariant(ReactOwner.isValidOwner(owner)));\n // Check that `component` is still the current ref because we do not want to\n // detach the ref if another component stole it.\n if (owner.getPublicInstance().refs[ref] === component.getPublicInstance()) {\n owner.detachRef(ref);\n }\n }\n\n};\n\nmodule.exports = ReactOwner;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactOwner.js\n ** module id = 99\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ReactOwner.js?");
|
||
|
||
/***/ },
|
||
/* 100 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/* WEBPACK VAR INJECTION */(function(process) {/**\n * Copyright 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 ReactUpdateQueue\n */\n\n'use strict';\n\nvar ReactLifeCycle = __webpack_require__(105);\nvar ReactCurrentOwner = __webpack_require__(78);\nvar ReactElement = __webpack_require__(79);\nvar ReactInstanceMap = __webpack_require__(91);\nvar ReactUpdates = __webpack_require__(101);\n\nvar assign = __webpack_require__(75);\nvar invariant = __webpack_require__(64);\nvar warning = __webpack_require__(82);\n\nfunction enqueueUpdate(internalInstance) {\n if (internalInstance !== ReactLifeCycle.currentlyMountingInstance) {\n // If we're in a componentWillMount handler, don't enqueue a rerender\n // because ReactUpdates assumes we're in a browser context (which is\n // wrong for server rendering) and we're about to do a render anyway.\n // See bug in #1740.\n ReactUpdates.enqueueUpdate(internalInstance);\n }\n}\n\nfunction getInternalInstanceReadyForUpdate(publicInstance, callerName) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n ReactCurrentOwner.current == null,\n '%s(...): Cannot update during an existing state transition ' +\n '(such as within `render`). Render methods should be a pure function ' +\n 'of props and state.',\n callerName\n ) : invariant(ReactCurrentOwner.current == null));\n\n var internalInstance = ReactInstanceMap.get(publicInstance);\n if (!internalInstance) {\n if (\"production\" !== process.env.NODE_ENV) {\n // Only warn when we have a callerName. Otherwise we should be silent.\n // We're probably calling from enqueueCallback. We don't want to warn\n // there because we already warned for the corresponding lifecycle method.\n (\"production\" !== process.env.NODE_ENV ? warning(\n !callerName,\n '%s(...): Can only update a mounted or mounting component. ' +\n 'This usually means you called %s() on an unmounted ' +\n 'component. This is a no-op.',\n callerName,\n callerName\n ) : null);\n }\n return null;\n }\n\n if (internalInstance === ReactLifeCycle.currentlyUnmountingInstance) {\n return null;\n }\n\n return internalInstance;\n}\n\n/**\n * ReactUpdateQueue allows for state updates to be scheduled into a later\n * reconciliation step.\n */\nvar ReactUpdateQueue = {\n\n /**\n * Enqueue a callback that will be executed after all the pending updates\n * have processed.\n *\n * @param {ReactClass} publicInstance The instance to use as `this` context.\n * @param {?function} callback Called after state is updated.\n * @internal\n */\n enqueueCallback: function(publicInstance, callback) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n typeof callback === 'function',\n 'enqueueCallback(...): You called `setProps`, `replaceProps`, ' +\n '`setState`, `replaceState`, or `forceUpdate` with a callback that ' +\n 'isn\\'t callable.'\n ) : invariant(typeof callback === 'function'));\n var internalInstance = getInternalInstanceReadyForUpdate(publicInstance);\n\n // Previously we would throw an error if we didn't have an internal\n // instance. Since we want to make it a no-op instead, we mirror the same\n // behavior we have in other enqueue* methods.\n // We also need to ignore callbacks in componentWillMount. See\n // enqueueUpdates.\n if (!internalInstance ||\n internalInstance === ReactLifeCycle.currentlyMountingInstance) {\n return null;\n }\n\n if (internalInstance._pendingCallbacks) {\n internalInstance._pendingCallbacks.push(callback);\n } else {\n internalInstance._pendingCallbacks = [callback];\n }\n // TODO: The callback here is ignored when setState is called from\n // componentWillMount. Either fix it or disallow doing so completely in\n // favor of getInitialState. Alternatively, we can disallow\n // componentWillMount during server-side rendering.\n enqueueUpdate(internalInstance);\n },\n\n enqueueCallbackInternal: function(internalInstance, callback) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n typeof callback === 'function',\n 'enqueueCallback(...): You called `setProps`, `replaceProps`, ' +\n '`setState`, `replaceState`, or `forceUpdate` with a callback that ' +\n 'isn\\'t callable.'\n ) : invariant(typeof callback === 'function'));\n if (internalInstance._pendingCallbacks) {\n internalInstance._pendingCallbacks.push(callback);\n } else {\n internalInstance._pendingCallbacks = [callback];\n }\n enqueueUpdate(internalInstance);\n },\n\n /**\n * Forces an update. This should only be invoked when it is known with\n * certainty that we are **not** in a DOM transaction.\n *\n * You may want to call this when you know that some deeper aspect of the\n * component's state has changed but `setState` was not called.\n *\n * This will not invoke `shouldUpdateComponent`, but it will invoke\n * `componentWillUpdate` and `componentDidUpdate`.\n *\n * @param {ReactClass} publicInstance The instance that should rerender.\n * @internal\n */\n enqueueForceUpdate: function(publicInstance) {\n var internalInstance = getInternalInstanceReadyForUpdate(\n publicInstance,\n 'forceUpdate'\n );\n\n if (!internalInstance) {\n return;\n }\n\n internalInstance._pendingForceUpdate = true;\n\n enqueueUpdate(internalInstance);\n },\n\n /**\n * Replaces all of the state. Always use this or `setState` to mutate state.\n * You should treat `this.state` as immutable.\n *\n * There is no guarantee that `this.state` will be immediately updated, so\n * accessing `this.state` after calling this method may return the old value.\n *\n * @param {ReactClass} publicInstance The instance that should rerender.\n * @param {object} completeState Next state.\n * @internal\n */\n enqueueReplaceState: function(publicInstance, completeState) {\n var internalInstance = getInternalInstanceReadyForUpdate(\n publicInstance,\n 'replaceState'\n );\n\n if (!internalInstance) {\n return;\n }\n\n internalInstance._pendingStateQueue = [completeState];\n internalInstance._pendingReplaceState = true;\n\n enqueueUpdate(internalInstance);\n },\n\n /**\n * Sets a subset of the state. This only exists because _pendingState is\n * internal. This provides a merging strategy that is not available to deep\n * properties which is confusing. TODO: Expose pendingState or don't use it\n * during the merge.\n *\n * @param {ReactClass} publicInstance The instance that should rerender.\n * @param {object} partialState Next partial state to be merged with state.\n * @internal\n */\n enqueueSetState: function(publicInstance, partialState) {\n var internalInstance = getInternalInstanceReadyForUpdate(\n publicInstance,\n 'setState'\n );\n\n if (!internalInstance) {\n return;\n }\n\n var queue =\n internalInstance._pendingStateQueue ||\n (internalInstance._pendingStateQueue = []);\n queue.push(partialState);\n\n enqueueUpdate(internalInstance);\n },\n\n /**\n * Sets a subset of the props.\n *\n * @param {ReactClass} publicInstance The instance that should rerender.\n * @param {object} partialProps Subset of the next props.\n * @internal\n */\n enqueueSetProps: function(publicInstance, partialProps) {\n var internalInstance = getInternalInstanceReadyForUpdate(\n publicInstance,\n 'setProps'\n );\n\n if (!internalInstance) {\n return;\n }\n\n (\"production\" !== process.env.NODE_ENV ? invariant(\n internalInstance._isTopLevel,\n 'setProps(...): You called `setProps` on a ' +\n 'component with a parent. This is an anti-pattern since props will ' +\n 'get reactively updated when rendered. Instead, change the owner\\'s ' +\n '`render` method to pass the correct value as props to the component ' +\n 'where it is created.'\n ) : invariant(internalInstance._isTopLevel));\n\n // Merge with the pending element if it exists, otherwise with existing\n // element props.\n var element = internalInstance._pendingElement ||\n internalInstance._currentElement;\n var props = assign({}, element.props, partialProps);\n internalInstance._pendingElement = ReactElement.cloneAndReplaceProps(\n element,\n props\n );\n\n enqueueUpdate(internalInstance);\n },\n\n /**\n * Replaces all of the props.\n *\n * @param {ReactClass} publicInstance The instance that should rerender.\n * @param {object} props New props.\n * @internal\n */\n enqueueReplaceProps: function(publicInstance, props) {\n var internalInstance = getInternalInstanceReadyForUpdate(\n publicInstance,\n 'replaceProps'\n );\n\n if (!internalInstance) {\n return;\n }\n\n (\"production\" !== process.env.NODE_ENV ? invariant(\n internalInstance._isTopLevel,\n 'replaceProps(...): You called `replaceProps` on a ' +\n 'component with a parent. This is an anti-pattern since props will ' +\n 'get reactively updated when rendered. Instead, change the owner\\'s ' +\n '`render` method to pass the correct value as props to the component ' +\n 'where it is created.'\n ) : invariant(internalInstance._isTopLevel));\n\n // Merge with the pending element if it exists, otherwise with existing\n // element props.\n var element = internalInstance._pendingElement ||\n internalInstance._currentElement;\n internalInstance._pendingElement = ReactElement.cloneAndReplaceProps(\n element,\n props\n );\n\n enqueueUpdate(internalInstance);\n },\n\n enqueueElementInternal: function(internalInstance, newElement) {\n internalInstance._pendingElement = newElement;\n enqueueUpdate(internalInstance);\n }\n\n};\n\nmodule.exports = ReactUpdateQueue;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactUpdateQueue.js\n ** module id = 100\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ReactUpdateQueue.js?");
|
||
|
||
/***/ },
|
||
/* 101 */
|
||
/***/ 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 ReactUpdates\n */\n\n'use strict';\n\nvar CallbackQueue = __webpack_require__(102);\nvar PooledClass = __webpack_require__(103);\nvar ReactCurrentOwner = __webpack_require__(78);\nvar ReactPerf = __webpack_require__(96);\nvar ReactReconciler = __webpack_require__(97);\nvar Transaction = __webpack_require__(104);\n\nvar assign = __webpack_require__(75);\nvar invariant = __webpack_require__(64);\nvar warning = __webpack_require__(82);\n\nvar dirtyComponents = [];\nvar asapCallbackQueue = CallbackQueue.getPooled();\nvar asapEnqueued = false;\n\nvar batchingStrategy = null;\n\nfunction ensureInjected() {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n ReactUpdates.ReactReconcileTransaction && batchingStrategy,\n 'ReactUpdates: must inject a reconcile transaction class and batching ' +\n 'strategy'\n ) : invariant(ReactUpdates.ReactReconcileTransaction && batchingStrategy));\n}\n\nvar NESTED_UPDATES = {\n initialize: function() {\n this.dirtyComponentsLength = dirtyComponents.length;\n },\n close: function() {\n if (this.dirtyComponentsLength !== dirtyComponents.length) {\n // Additional updates were enqueued by componentDidUpdate handlers or\n // similar; before our own UPDATE_QUEUEING wrapper closes, we want to run\n // these new updates so that if A's componentDidUpdate calls setState on\n // B, B will update before the callback A's updater provided when calling\n // setState.\n dirtyComponents.splice(0, this.dirtyComponentsLength);\n flushBatchedUpdates();\n } else {\n dirtyComponents.length = 0;\n }\n }\n};\n\nvar UPDATE_QUEUEING = {\n initialize: function() {\n this.callbackQueue.reset();\n },\n close: function() {\n this.callbackQueue.notifyAll();\n }\n};\n\nvar TRANSACTION_WRAPPERS = [NESTED_UPDATES, UPDATE_QUEUEING];\n\nfunction ReactUpdatesFlushTransaction() {\n this.reinitializeTransaction();\n this.dirtyComponentsLength = null;\n this.callbackQueue = CallbackQueue.getPooled();\n this.reconcileTransaction =\n ReactUpdates.ReactReconcileTransaction.getPooled();\n}\n\nassign(\n ReactUpdatesFlushTransaction.prototype,\n Transaction.Mixin, {\n getTransactionWrappers: function() {\n return TRANSACTION_WRAPPERS;\n },\n\n destructor: function() {\n this.dirtyComponentsLength = null;\n CallbackQueue.release(this.callbackQueue);\n this.callbackQueue = null;\n ReactUpdates.ReactReconcileTransaction.release(this.reconcileTransaction);\n this.reconcileTransaction = null;\n },\n\n perform: function(method, scope, a) {\n // Essentially calls `this.reconcileTransaction.perform(method, scope, a)`\n // with this transaction's wrappers around it.\n return Transaction.Mixin.perform.call(\n this,\n this.reconcileTransaction.perform,\n this.reconcileTransaction,\n method,\n scope,\n a\n );\n }\n});\n\nPooledClass.addPoolingTo(ReactUpdatesFlushTransaction);\n\nfunction batchedUpdates(callback, a, b, c, d) {\n ensureInjected();\n batchingStrategy.batchedUpdates(callback, a, b, c, d);\n}\n\n/**\n * Array comparator for ReactComponents by mount ordering.\n *\n * @param {ReactComponent} c1 first component you're comparing\n * @param {ReactComponent} c2 second component you're comparing\n * @return {number} Return value usable by Array.prototype.sort().\n */\nfunction mountOrderComparator(c1, c2) {\n return c1._mountOrder - c2._mountOrder;\n}\n\nfunction runBatchedUpdates(transaction) {\n var len = transaction.dirtyComponentsLength;\n (\"production\" !== process.env.NODE_ENV ? invariant(\n len === dirtyComponents.length,\n 'Expected flush transaction\\'s stored dirty-components length (%s) to ' +\n 'match dirty-components array length (%s).',\n len,\n dirtyComponents.length\n ) : invariant(len === dirtyComponents.length));\n\n // Since reconciling a component higher in the owner hierarchy usually (not\n // always -- see shouldComponentUpdate()) will reconcile children, reconcile\n // them before their children by sorting the array.\n dirtyComponents.sort(mountOrderComparator);\n\n for (var i = 0; i < len; i++) {\n // If a component is unmounted before pending changes apply, it will still\n // be here, but we assume that it has cleared its _pendingCallbacks and\n // that performUpdateIfNecessary is a noop.\n var component = dirtyComponents[i];\n\n // If performUpdateIfNecessary happens to enqueue any new updates, we\n // shouldn't execute the callbacks until the next render happens, so\n // stash the callbacks first\n var callbacks = component._pendingCallbacks;\n component._pendingCallbacks = null;\n\n ReactReconciler.performUpdateIfNecessary(\n component,\n transaction.reconcileTransaction\n );\n\n if (callbacks) {\n for (var j = 0; j < callbacks.length; j++) {\n transaction.callbackQueue.enqueue(\n callbacks[j],\n component.getPublicInstance()\n );\n }\n }\n }\n}\n\nvar flushBatchedUpdates = function() {\n // ReactUpdatesFlushTransaction's wrappers will clear the dirtyComponents\n // array and perform any updates enqueued by mount-ready handlers (i.e.,\n // componentDidUpdate) but we need to check here too in order to catch\n // updates enqueued by setState callbacks and asap calls.\n while (dirtyComponents.length || asapEnqueued) {\n if (dirtyComponents.length) {\n var transaction = ReactUpdatesFlushTransaction.getPooled();\n transaction.perform(runBatchedUpdates, null, transaction);\n ReactUpdatesFlushTransaction.release(transaction);\n }\n\n if (asapEnqueued) {\n asapEnqueued = false;\n var queue = asapCallbackQueue;\n asapCallbackQueue = CallbackQueue.getPooled();\n queue.notifyAll();\n CallbackQueue.release(queue);\n }\n }\n};\nflushBatchedUpdates = ReactPerf.measure(\n 'ReactUpdates',\n 'flushBatchedUpdates',\n flushBatchedUpdates\n);\n\n/**\n * Mark a component as needing a rerender, adding an optional callback to a\n * list of functions which will be executed once the rerender occurs.\n */\nfunction enqueueUpdate(component) {\n ensureInjected();\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. (This is called by each top-level update\n // function, like setProps, setState, forceUpdate, etc.; creation and\n // destruction of top-level components is guarded in ReactMount.)\n (\"production\" !== process.env.NODE_ENV ? warning(\n ReactCurrentOwner.current == null,\n 'enqueueUpdate(): Render methods should be a pure function of props ' +\n 'and state; triggering nested component updates from render is not ' +\n 'allowed. If necessary, trigger nested updates in ' +\n 'componentDidUpdate.'\n ) : null);\n\n if (!batchingStrategy.isBatchingUpdates) {\n batchingStrategy.batchedUpdates(enqueueUpdate, component);\n return;\n }\n\n dirtyComponents.push(component);\n}\n\n/**\n * Enqueue a callback to be run at the end of the current batching cycle. Throws\n * if no updates are currently being performed.\n */\nfunction asap(callback, context) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n batchingStrategy.isBatchingUpdates,\n 'ReactUpdates.asap: Can\\'t enqueue an asap callback in a context where' +\n 'updates are not being batched.'\n ) : invariant(batchingStrategy.isBatchingUpdates));\n asapCallbackQueue.enqueue(callback, context);\n asapEnqueued = true;\n}\n\nvar ReactUpdatesInjection = {\n injectReconcileTransaction: function(ReconcileTransaction) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n ReconcileTransaction,\n 'ReactUpdates: must provide a reconcile transaction class'\n ) : invariant(ReconcileTransaction));\n ReactUpdates.ReactReconcileTransaction = ReconcileTransaction;\n },\n\n injectBatchingStrategy: function(_batchingStrategy) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n _batchingStrategy,\n 'ReactUpdates: must provide a batching strategy'\n ) : invariant(_batchingStrategy));\n (\"production\" !== process.env.NODE_ENV ? invariant(\n typeof _batchingStrategy.batchedUpdates === 'function',\n 'ReactUpdates: must provide a batchedUpdates() function'\n ) : invariant(typeof _batchingStrategy.batchedUpdates === 'function'));\n (\"production\" !== process.env.NODE_ENV ? invariant(\n typeof _batchingStrategy.isBatchingUpdates === 'boolean',\n 'ReactUpdates: must provide an isBatchingUpdates boolean attribute'\n ) : invariant(typeof _batchingStrategy.isBatchingUpdates === 'boolean'));\n batchingStrategy = _batchingStrategy;\n }\n};\n\nvar ReactUpdates = {\n /**\n * React references `ReactReconcileTransaction` using this property in order\n * to allow dependency injection.\n *\n * @internal\n */\n ReactReconcileTransaction: null,\n\n batchedUpdates: batchedUpdates,\n enqueueUpdate: enqueueUpdate,\n flushBatchedUpdates: flushBatchedUpdates,\n injection: ReactUpdatesInjection,\n asap: asap\n};\n\nmodule.exports = ReactUpdates;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactUpdates.js\n ** module id = 101\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ReactUpdates.js?");
|
||
|
||
/***/ },
|
||
/* 102 */
|
||
/***/ 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 CallbackQueue\n */\n\n'use strict';\n\nvar PooledClass = __webpack_require__(103);\n\nvar assign = __webpack_require__(75);\nvar invariant = __webpack_require__(64);\n\n/**\n * A specialized pseudo-event module to help keep track of components waiting to\n * be notified when their DOM representations are available for use.\n *\n * This implements `PooledClass`, so you should never need to instantiate this.\n * Instead, use `CallbackQueue.getPooled()`.\n *\n * @class ReactMountReady\n * @implements PooledClass\n * @internal\n */\nfunction CallbackQueue() {\n this._callbacks = null;\n this._contexts = null;\n}\n\nassign(CallbackQueue.prototype, {\n\n /**\n * Enqueues a callback to be invoked when `notifyAll` is invoked.\n *\n * @param {function} callback Invoked when `notifyAll` is invoked.\n * @param {?object} context Context to call `callback` with.\n * @internal\n */\n enqueue: function(callback, context) {\n this._callbacks = this._callbacks || [];\n this._contexts = this._contexts || [];\n this._callbacks.push(callback);\n this._contexts.push(context);\n },\n\n /**\n * Invokes all enqueued callbacks and clears the queue. This is invoked after\n * the DOM representation of a component has been created or updated.\n *\n * @internal\n */\n notifyAll: function() {\n var callbacks = this._callbacks;\n var contexts = this._contexts;\n if (callbacks) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n callbacks.length === contexts.length,\n 'Mismatched list of contexts in callback queue'\n ) : invariant(callbacks.length === contexts.length));\n this._callbacks = null;\n this._contexts = null;\n for (var i = 0, l = callbacks.length; i < l; i++) {\n callbacks[i].call(contexts[i]);\n }\n callbacks.length = 0;\n contexts.length = 0;\n }\n },\n\n /**\n * Resets the internal queue.\n *\n * @internal\n */\n reset: function() {\n this._callbacks = null;\n this._contexts = null;\n },\n\n /**\n * `PooledClass` looks for this.\n */\n destructor: function() {\n this.reset();\n }\n\n});\n\nPooledClass.addPoolingTo(CallbackQueue);\n\nmodule.exports = CallbackQueue;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/CallbackQueue.js\n ** module id = 102\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/CallbackQueue.js?");
|
||
|
||
/***/ },
|
||
/* 103 */
|
||
/***/ 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 PooledClass\n */\n\n'use strict';\n\nvar invariant = __webpack_require__(64);\n\n/**\n * Static poolers. Several custom versions for each potential number of\n * arguments. A completely generic pooler is easy to implement, but would\n * require accessing the `arguments` object. In each of these, `this` refers to\n * the Class itself, not an instance. If any others are needed, simply add them\n * here, or in their own files.\n */\nvar oneArgumentPooler = function(copyFieldsFrom) {\n var Klass = this;\n if (Klass.instancePool.length) {\n var instance = Klass.instancePool.pop();\n Klass.call(instance, copyFieldsFrom);\n return instance;\n } else {\n return new Klass(copyFieldsFrom);\n }\n};\n\nvar twoArgumentPooler = function(a1, a2) {\n var Klass = this;\n if (Klass.instancePool.length) {\n var instance = Klass.instancePool.pop();\n Klass.call(instance, a1, a2);\n return instance;\n } else {\n return new Klass(a1, a2);\n }\n};\n\nvar threeArgumentPooler = function(a1, a2, a3) {\n var Klass = this;\n if (Klass.instancePool.length) {\n var instance = Klass.instancePool.pop();\n Klass.call(instance, a1, a2, a3);\n return instance;\n } else {\n return new Klass(a1, a2, a3);\n }\n};\n\nvar fiveArgumentPooler = function(a1, a2, a3, a4, a5) {\n var Klass = this;\n if (Klass.instancePool.length) {\n var instance = Klass.instancePool.pop();\n Klass.call(instance, a1, a2, a3, a4, a5);\n return instance;\n } else {\n return new Klass(a1, a2, a3, a4, a5);\n }\n};\n\nvar standardReleaser = function(instance) {\n var Klass = this;\n (\"production\" !== process.env.NODE_ENV ? invariant(\n instance instanceof Klass,\n 'Trying to release an instance into a pool of a different type.'\n ) : invariant(instance instanceof Klass));\n if (instance.destructor) {\n instance.destructor();\n }\n if (Klass.instancePool.length < Klass.poolSize) {\n Klass.instancePool.push(instance);\n }\n};\n\nvar DEFAULT_POOL_SIZE = 10;\nvar DEFAULT_POOLER = oneArgumentPooler;\n\n/**\n * Augments `CopyConstructor` to be a poolable class, augmenting only the class\n * itself (statically) not adding any prototypical fields. Any CopyConstructor\n * you give this may have a `poolSize` property, and will look for a\n * prototypical `destructor` on instances (optional).\n *\n * @param {Function} CopyConstructor Constructor that can be used to reset.\n * @param {Function} pooler Customizable pooler.\n */\nvar addPoolingTo = function(CopyConstructor, pooler) {\n var NewKlass = CopyConstructor;\n NewKlass.instancePool = [];\n NewKlass.getPooled = pooler || DEFAULT_POOLER;\n if (!NewKlass.poolSize) {\n NewKlass.poolSize = DEFAULT_POOL_SIZE;\n }\n NewKlass.release = standardReleaser;\n return NewKlass;\n};\n\nvar PooledClass = {\n addPoolingTo: addPoolingTo,\n oneArgumentPooler: oneArgumentPooler,\n twoArgumentPooler: twoArgumentPooler,\n threeArgumentPooler: threeArgumentPooler,\n fiveArgumentPooler: fiveArgumentPooler\n};\n\nmodule.exports = PooledClass;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/PooledClass.js\n ** module id = 103\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/PooledClass.js?");
|
||
|
||
/***/ },
|
||
/* 104 */
|
||
/***/ 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 Transaction\n */\n\n'use strict';\n\nvar invariant = __webpack_require__(64);\n\n/**\n * `Transaction` creates a black box that is able to wrap any method such that\n * certain invariants are maintained before and after the method is invoked\n * (Even if an exception is thrown while invoking the wrapped method). Whoever\n * instantiates a transaction can provide enforcers of the invariants at\n * creation time. The `Transaction` class itself will supply one additional\n * automatic invariant for you - the invariant that any transaction instance\n * should not be run while it is already being run. You would typically create a\n * single instance of a `Transaction` for reuse multiple times, that potentially\n * is used to wrap several different methods. Wrappers are extremely simple -\n * they only require implementing two methods.\n *\n * <pre>\n * wrappers (injected at creation time)\n * + +\n * | |\n * +-----------------|--------|--------------+\n * | v | |\n * | +---------------+ | |\n * | +--| wrapper1 |---|----+ |\n * | | +---------------+ v | |\n * | | +-------------+ | |\n * | | +----| wrapper2 |--------+ |\n * | | | +-------------+ | | |\n * | | | | | |\n * | v v v v | wrapper\n * | +---+ +---+ +---------+ +---+ +---+ | invariants\n * perform(anyMethod) | | | | | | | | | | | | maintained\n * +----------------->|-|---|-|---|-->|anyMethod|---|---|-|---|-|-------->\n * | | | | | | | | | | | |\n * | | | | | | | | | | | |\n * | | | | | | | | | | | |\n * | +---+ +---+ +---------+ +---+ +---+ |\n * | initialize close |\n * +-----------------------------------------+\n * </pre>\n *\n * Use cases:\n * - Preserving the input selection ranges before/after reconciliation.\n * Restoring selection even in the event of an unexpected error.\n * - Deactivating events while rearranging the DOM, preventing blurs/focuses,\n * while guaranteeing that afterwards, the event system is reactivated.\n * - Flushing a queue of collected DOM mutations to the main UI thread after a\n * reconciliation takes place in a worker thread.\n * - Invoking any collected `componentDidUpdate` callbacks after rendering new\n * content.\n * - (Future use case): Wrapping particular flushes of the `ReactWorker` queue\n * to preserve the `scrollTop` (an automatic scroll aware DOM).\n * - (Future use case): Layout calculations before and after DOM updates.\n *\n * Transactional plugin API:\n * - A module that has an `initialize` method that returns any precomputation.\n * - and a `close` method that accepts the precomputation. `close` is invoked\n * when the wrapped process is completed, or has failed.\n *\n * @param {Array<TransactionalWrapper>} transactionWrapper Wrapper modules\n * that implement `initialize` and `close`.\n * @return {Transaction} Single transaction for reuse in thread.\n *\n * @class Transaction\n */\nvar Mixin = {\n /**\n * Sets up this instance so that it is prepared for collecting metrics. Does\n * so such that this setup method may be used on an instance that is already\n * initialized, in a way that does not consume additional memory upon reuse.\n * That can be useful if you decide to make your subclass of this mixin a\n * \"PooledClass\".\n */\n reinitializeTransaction: function() {\n this.transactionWrappers = this.getTransactionWrappers();\n if (!this.wrapperInitData) {\n this.wrapperInitData = [];\n } else {\n this.wrapperInitData.length = 0;\n }\n this._isInTransaction = false;\n },\n\n _isInTransaction: false,\n\n /**\n * @abstract\n * @return {Array<TransactionWrapper>} Array of transaction wrappers.\n */\n getTransactionWrappers: null,\n\n isInTransaction: function() {\n return !!this._isInTransaction;\n },\n\n /**\n * Executes the function within a safety window. Use this for the top level\n * methods that result in large amounts of computation/mutations that would\n * need to be safety checked.\n *\n * @param {function} method Member of scope to call.\n * @param {Object} scope Scope to invoke from.\n * @param {Object?=} args... Arguments to pass to the method (optional).\n * Helps prevent need to bind in many cases.\n * @return Return value from `method`.\n */\n perform: function(method, scope, a, b, c, d, e, f) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n !this.isInTransaction(),\n 'Transaction.perform(...): Cannot initialize a transaction when there ' +\n 'is already an outstanding transaction.'\n ) : invariant(!this.isInTransaction()));\n var errorThrown;\n var ret;\n try {\n this._isInTransaction = true;\n // Catching errors makes debugging more difficult, so we start with\n // errorThrown set to true before setting it to false after calling\n // close -- if it's still set to true in the finally block, it means\n // one of these calls threw.\n errorThrown = true;\n this.initializeAll(0);\n ret = method.call(scope, a, b, c, d, e, f);\n errorThrown = false;\n } finally {\n try {\n if (errorThrown) {\n // If `method` throws, prefer to show that stack trace over any thrown\n // by invoking `closeAll`.\n try {\n this.closeAll(0);\n } catch (err) {\n }\n } else {\n // Since `method` didn't throw, we don't want to silence the exception\n // here.\n this.closeAll(0);\n }\n } finally {\n this._isInTransaction = false;\n }\n }\n return ret;\n },\n\n initializeAll: function(startIndex) {\n var transactionWrappers = this.transactionWrappers;\n for (var i = startIndex; i < transactionWrappers.length; i++) {\n var wrapper = transactionWrappers[i];\n try {\n // Catching errors makes debugging more difficult, so we start with the\n // OBSERVED_ERROR state before overwriting it with the real return value\n // of initialize -- if it's still set to OBSERVED_ERROR in the finally\n // block, it means wrapper.initialize threw.\n this.wrapperInitData[i] = Transaction.OBSERVED_ERROR;\n this.wrapperInitData[i] = wrapper.initialize ?\n wrapper.initialize.call(this) :\n null;\n } finally {\n if (this.wrapperInitData[i] === Transaction.OBSERVED_ERROR) {\n // The initializer for wrapper i threw an error; initialize the\n // remaining wrappers but silence any exceptions from them to ensure\n // that the first error is the one to bubble up.\n try {\n this.initializeAll(i + 1);\n } catch (err) {\n }\n }\n }\n }\n },\n\n /**\n * Invokes each of `this.transactionWrappers.close[i]` functions, passing into\n * them the respective return values of `this.transactionWrappers.init[i]`\n * (`close`rs that correspond to initializers that failed will not be\n * invoked).\n */\n closeAll: function(startIndex) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n this.isInTransaction(),\n 'Transaction.closeAll(): Cannot close transaction when none are open.'\n ) : invariant(this.isInTransaction()));\n var transactionWrappers = this.transactionWrappers;\n for (var i = startIndex; i < transactionWrappers.length; i++) {\n var wrapper = transactionWrappers[i];\n var initData = this.wrapperInitData[i];\n var errorThrown;\n try {\n // Catching errors makes debugging more difficult, so we start with\n // errorThrown set to true before setting it to false after calling\n // close -- if it's still set to true in the finally block, it means\n // wrapper.close threw.\n errorThrown = true;\n if (initData !== Transaction.OBSERVED_ERROR && wrapper.close) {\n wrapper.close.call(this, initData);\n }\n errorThrown = false;\n } finally {\n if (errorThrown) {\n // The closer for wrapper i threw an error; close the remaining\n // wrappers but silence any exceptions from them to ensure that the\n // first error is the one to bubble up.\n try {\n this.closeAll(i + 1);\n } catch (e) {\n }\n }\n }\n }\n this.wrapperInitData.length = 0;\n }\n};\n\nvar Transaction = {\n\n Mixin: Mixin,\n\n /**\n * Token to look for to determine if an error occured.\n */\n OBSERVED_ERROR: {}\n\n};\n\nmodule.exports = Transaction;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/Transaction.js\n ** module id = 104\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/Transaction.js?");
|
||
|
||
/***/ },
|
||
/* 105 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("/**\n * Copyright 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 ReactLifeCycle\n */\n\n'use strict';\n\n/**\n * This module manages the bookkeeping when a component is in the process\n * of being mounted or being unmounted. This is used as a way to enforce\n * invariants (or warnings) when it is not recommended to call\n * setState/forceUpdate.\n *\n * currentlyMountingInstance: During the construction phase, it is not possible\n * to trigger an update since the instance is not fully mounted yet. However, we\n * currently allow this as a convenience for mutating the initial state.\n *\n * currentlyUnmountingInstance: During the unmounting phase, the instance is\n * still mounted and can therefore schedule an update. However, this is not\n * recommended and probably an error since it's about to be unmounted.\n * Therefore we still want to trigger in an error for that case.\n */\n\nvar ReactLifeCycle = {\n currentlyMountingInstance: null,\n currentlyUnmountingInstance: null\n};\n\nmodule.exports = ReactLifeCycle;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactLifeCycle.js\n ** module id = 105\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ReactLifeCycle.js?");
|
||
|
||
/***/ },
|
||
/* 106 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\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 containsNode\n * @typechecks\n */\n\nvar isTextNode = __webpack_require__(107);\n\n/*jslint bitwise:true */\n\n/**\n * Checks if a given DOM node contains or is another DOM node.\n *\n * @param {?DOMNode} outerNode Outer DOM node.\n * @param {?DOMNode} innerNode Inner DOM node.\n * @return {boolean} True if `outerNode` contains or is `innerNode`.\n */\nfunction containsNode(outerNode, innerNode) {\n if (!outerNode || !innerNode) {\n return false;\n } else if (outerNode === innerNode) {\n return true;\n } else if (isTextNode(outerNode)) {\n return false;\n } else if (isTextNode(innerNode)) {\n return containsNode(outerNode, innerNode.parentNode);\n } else if (outerNode.contains) {\n return outerNode.contains(innerNode);\n } else if (outerNode.compareDocumentPosition) {\n return !!(outerNode.compareDocumentPosition(innerNode) & 16);\n } else {\n return false;\n }\n}\n\nmodule.exports = containsNode;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/containsNode.js\n ** module id = 106\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/containsNode.js?");
|
||
|
||
/***/ },
|
||
/* 107 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\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 isTextNode\n * @typechecks\n */\n\nvar isNode = __webpack_require__(108);\n\n/**\n * @param {*} object The object to check.\n * @return {boolean} Whether or not the object is a DOM text node.\n */\nfunction isTextNode(object) {\n return isNode(object) && object.nodeType == 3;\n}\n\nmodule.exports = isTextNode;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/isTextNode.js\n ** module id = 107\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/isTextNode.js?");
|
||
|
||
/***/ },
|
||
/* 108 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("/**\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 isNode\n * @typechecks\n */\n\n/**\n * @param {*} object The object to check.\n * @return {boolean} Whether or not the object is a DOM node.\n */\nfunction isNode(object) {\n return !!(object && (\n ((typeof Node === 'function' ? object instanceof Node : typeof object === 'object' &&\n typeof object.nodeType === 'number' &&\n typeof object.nodeName === 'string'))\n ));\n}\n\nmodule.exports = isNode;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/isNode.js\n ** module id = 108\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/isNode.js?");
|
||
|
||
/***/ },
|
||
/* 109 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("/**\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 getReactRootElementInContainer\n */\n\n'use strict';\n\nvar DOC_NODE_TYPE = 9;\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\nmodule.exports = getReactRootElementInContainer;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/getReactRootElementInContainer.js\n ** module id = 109\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/getReactRootElementInContainer.js?");
|
||
|
||
/***/ },
|
||
/* 110 */
|
||
/***/ 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 instantiateReactComponent\n * @typechecks static-only\n */\n\n'use strict';\n\nvar ReactCompositeComponent = __webpack_require__(111);\nvar ReactEmptyComponent = __webpack_require__(90);\nvar ReactNativeComponent = __webpack_require__(88);\n\nvar assign = __webpack_require__(75);\nvar invariant = __webpack_require__(64);\nvar warning = __webpack_require__(82);\n\n// To avoid a cyclic dependency, we create the final class in this module\nvar ReactCompositeComponentWrapper = function() { };\nassign(\n ReactCompositeComponentWrapper.prototype,\n ReactCompositeComponent.Mixin,\n {\n _instantiateReactComponent: instantiateReactComponent\n }\n);\n\n/**\n * Check if the type reference is a known internal type. I.e. not a user\n * provided composite type.\n *\n * @param {function} type\n * @return {boolean} Returns true if this is a valid internal type.\n */\nfunction isInternalComponentType(type) {\n return (\n typeof type === 'function' &&\n typeof type.prototype !== 'undefined' &&\n typeof type.prototype.mountComponent === 'function' &&\n typeof type.prototype.receiveComponent === 'function'\n );\n}\n\n/**\n * Given a ReactNode, create an instance that will actually be mounted.\n *\n * @param {ReactNode} node\n * @param {*} parentCompositeType The composite type that resolved this.\n * @return {object} A new instance of the element's constructor.\n * @protected\n */\nfunction instantiateReactComponent(node, parentCompositeType) {\n var instance;\n\n if (node === null || node === false) {\n node = ReactEmptyComponent.emptyElement;\n }\n\n if (typeof node === 'object') {\n var element = node;\n if (\"production\" !== process.env.NODE_ENV) {\n (\"production\" !== process.env.NODE_ENV ? warning(\n element && (typeof element.type === 'function' ||\n typeof element.type === 'string'),\n 'Only functions or strings can be mounted as React components.'\n ) : null);\n }\n\n // Special case string values\n if (parentCompositeType === element.type &&\n typeof element.type === 'string') {\n // Avoid recursion if the wrapper renders itself.\n instance = ReactNativeComponent.createInternalComponent(element);\n // All native components are currently wrapped in a composite so we're\n // safe to assume that this is what we should instantiate.\n } else if (isInternalComponentType(element.type)) {\n // This is temporarily available for custom components that are not string\n // represenations. I.e. ART. Once those are updated to use the string\n // representation, we can drop this code path.\n instance = new element.type(element);\n } else {\n instance = new ReactCompositeComponentWrapper();\n }\n } else if (typeof node === 'string' || typeof node === 'number') {\n instance = ReactNativeComponent.createInstanceForText(node);\n } else {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n false,\n 'Encountered invalid React node of type %s',\n typeof node\n ) : invariant(false));\n }\n\n if (\"production\" !== process.env.NODE_ENV) {\n (\"production\" !== process.env.NODE_ENV ? warning(\n typeof instance.construct === 'function' &&\n typeof instance.mountComponent === 'function' &&\n typeof instance.receiveComponent === 'function' &&\n typeof instance.unmountComponent === 'function',\n 'Only React Components can be mounted.'\n ) : null);\n }\n\n // Sets up the instance. This can probably just move into the constructor now.\n instance.construct(node);\n\n // These two fields are used by the DOM and ART diffing algorithms\n // respectively. Instead of using expandos on components, we should be\n // storing the state needed by the diffing algorithms elsewhere.\n instance._mountIndex = 0;\n instance._mountImage = null;\n\n if (\"production\" !== process.env.NODE_ENV) {\n instance._isOwnerNecessary = false;\n instance._warnedAboutRefsInRender = false;\n }\n\n // Internal instances should fully constructed at this point, so they should\n // not get any new fields added to them at this point.\n if (\"production\" !== process.env.NODE_ENV) {\n if (Object.preventExtensions) {\n Object.preventExtensions(instance);\n }\n }\n\n return instance;\n}\n\nmodule.exports = instantiateReactComponent;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/instantiateReactComponent.js\n ** module id = 110\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/instantiateReactComponent.js?");
|
||
|
||
/***/ },
|
||
/* 111 */
|
||
/***/ 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 ReactCompositeComponent\n */\n\n'use strict';\n\nvar ReactComponentEnvironment = __webpack_require__(112);\nvar ReactContext = __webpack_require__(80);\nvar ReactCurrentOwner = __webpack_require__(78);\nvar ReactElement = __webpack_require__(79);\nvar ReactElementValidator = __webpack_require__(84);\nvar ReactInstanceMap = __webpack_require__(91);\nvar ReactLifeCycle = __webpack_require__(105);\nvar ReactNativeComponent = __webpack_require__(88);\nvar ReactPerf = __webpack_require__(96);\nvar ReactPropTypeLocations = __webpack_require__(86);\nvar ReactPropTypeLocationNames = __webpack_require__(87);\nvar ReactReconciler = __webpack_require__(97);\nvar ReactUpdates = __webpack_require__(101);\n\nvar assign = __webpack_require__(75);\nvar emptyObject = __webpack_require__(81);\nvar invariant = __webpack_require__(64);\nvar shouldUpdateReactComponent = __webpack_require__(113);\nvar warning = __webpack_require__(82);\n\nfunction getDeclarationErrorAddendum(component) {\n var owner = component._currentElement._owner || null;\n if (owner) {\n var name = owner.getName();\n if (name) {\n return ' Check the render method of `' + name + '`.';\n }\n }\n return '';\n}\n\n/**\n * ------------------ The Life-Cycle of a Composite Component ------------------\n *\n * - constructor: Initialization of state. The instance is now retained.\n * - componentWillMount\n * - render\n * - [children's constructors]\n * - [children's componentWillMount and render]\n * - [children's componentDidMount]\n * - componentDidMount\n *\n * Update Phases:\n * - componentWillReceiveProps (only called if parent updated)\n * - shouldComponentUpdate\n * - componentWillUpdate\n * - render\n * - [children's constructors or receive props phases]\n * - componentDidUpdate\n *\n * - componentWillUnmount\n * - [children's componentWillUnmount]\n * - [children destroyed]\n * - (destroyed): The instance is now blank, released by React and ready for GC.\n *\n * -----------------------------------------------------------------------------\n */\n\n/**\n * An incrementing ID assigned to each component when it is mounted. This is\n * used to enforce the order in which `ReactUpdates` updates dirty components.\n *\n * @private\n */\nvar nextMountID = 1;\n\n/**\n * @lends {ReactCompositeComponent.prototype}\n */\nvar ReactCompositeComponentMixin = {\n\n /**\n * Base constructor for all composite component.\n *\n * @param {ReactElement} element\n * @final\n * @internal\n */\n construct: function(element) {\n this._currentElement = element;\n this._rootNodeID = null;\n this._instance = null;\n\n // See ReactUpdateQueue\n this._pendingElement = null;\n this._pendingStateQueue = null;\n this._pendingReplaceState = false;\n this._pendingForceUpdate = false;\n\n this._renderedComponent = null;\n\n this._context = null;\n this._mountOrder = 0;\n this._isTopLevel = false;\n\n // See ReactUpdates and ReactUpdateQueue.\n this._pendingCallbacks = null;\n },\n\n /**\n * Initializes the component, renders markup, and registers event listeners.\n *\n * @param {string} rootID DOM ID of the root node.\n * @param {ReactReconcileTransaction|ReactServerRenderingTransaction} transaction\n * @return {?string} Rendered markup to be inserted into the DOM.\n * @final\n * @internal\n */\n mountComponent: function(rootID, transaction, context) {\n this._context = context;\n this._mountOrder = nextMountID++;\n this._rootNodeID = rootID;\n\n var publicProps = this._processProps(this._currentElement.props);\n var publicContext = this._processContext(this._currentElement._context);\n\n var Component = ReactNativeComponent.getComponentClassForElement(\n this._currentElement\n );\n\n // Initialize the public class\n var inst = new Component(publicProps, publicContext);\n\n if (\"production\" !== process.env.NODE_ENV) {\n // This will throw later in _renderValidatedComponent, but add an early\n // warning now to help debugging\n (\"production\" !== process.env.NODE_ENV ? warning(\n inst.render != null,\n '%s(...): No `render` method found on the returned component ' +\n 'instance: you may have forgotten to define `render` in your ' +\n 'component or you may have accidentally tried to render an element ' +\n 'whose type is a function that isn\\'t a React component.',\n Component.displayName || Component.name || 'Component'\n ) : null);\n }\n\n // These should be set up in the constructor, but as a convenience for\n // simpler class abstractions, we set them up after the fact.\n inst.props = publicProps;\n inst.context = publicContext;\n inst.refs = emptyObject;\n\n this._instance = inst;\n\n // Store a reference from the instance back to the internal representation\n ReactInstanceMap.set(inst, this);\n\n if (\"production\" !== process.env.NODE_ENV) {\n this._warnIfContextsDiffer(this._currentElement._context, context);\n }\n\n if (\"production\" !== process.env.NODE_ENV) {\n // Since plain JS classes are defined without any special initialization\n // logic, we can not catch common errors early. Therefore, we have to\n // catch them here, at initialization time, instead.\n (\"production\" !== process.env.NODE_ENV ? warning(\n !inst.getInitialState ||\n inst.getInitialState.isReactClassApproved,\n 'getInitialState was defined on %s, a plain JavaScript class. ' +\n 'This is only supported for classes created using React.createClass. ' +\n 'Did you mean to define a state property instead?',\n this.getName() || 'a component'\n ) : null);\n (\"production\" !== process.env.NODE_ENV ? warning(\n !inst.getDefaultProps ||\n inst.getDefaultProps.isReactClassApproved,\n 'getDefaultProps was defined on %s, a plain JavaScript class. ' +\n 'This is only supported for classes created using React.createClass. ' +\n 'Use a static property to define defaultProps instead.',\n this.getName() || 'a component'\n ) : null);\n (\"production\" !== process.env.NODE_ENV ? warning(\n !inst.propTypes,\n 'propTypes was defined as an instance property on %s. Use a static ' +\n 'property to define propTypes instead.',\n this.getName() || 'a component'\n ) : null);\n (\"production\" !== process.env.NODE_ENV ? warning(\n !inst.contextTypes,\n 'contextTypes was defined as an instance property on %s. Use a ' +\n 'static property to define contextTypes instead.',\n this.getName() || 'a component'\n ) : null);\n (\"production\" !== process.env.NODE_ENV ? warning(\n typeof inst.componentShouldUpdate !== 'function',\n '%s has a method called ' +\n 'componentShouldUpdate(). Did you mean shouldComponentUpdate()? ' +\n 'The name is phrased as a question because the function is ' +\n 'expected to return a value.',\n (this.getName() || 'A component')\n ) : null);\n }\n\n var initialState = inst.state;\n if (initialState === undefined) {\n inst.state = initialState = null;\n }\n (\"production\" !== process.env.NODE_ENV ? invariant(\n typeof initialState === 'object' && !Array.isArray(initialState),\n '%s.state: must be set to an object or null',\n this.getName() || 'ReactCompositeComponent'\n ) : invariant(typeof initialState === 'object' && !Array.isArray(initialState)));\n\n this._pendingStateQueue = null;\n this._pendingReplaceState = false;\n this._pendingForceUpdate = false;\n\n var childContext;\n var renderedElement;\n\n var previouslyMounting = ReactLifeCycle.currentlyMountingInstance;\n ReactLifeCycle.currentlyMountingInstance = this;\n try {\n if (inst.componentWillMount) {\n inst.componentWillMount();\n // When mounting, calls to `setState` by `componentWillMount` will set\n // `this._pendingStateQueue` without triggering a re-render.\n if (this._pendingStateQueue) {\n inst.state = this._processPendingState(inst.props, inst.context);\n }\n }\n\n childContext = this._getValidatedChildContext(context);\n renderedElement = this._renderValidatedComponent(childContext);\n } finally {\n ReactLifeCycle.currentlyMountingInstance = previouslyMounting;\n }\n\n this._renderedComponent = this._instantiateReactComponent(\n renderedElement,\n this._currentElement.type // The wrapping type\n );\n\n var markup = ReactReconciler.mountComponent(\n this._renderedComponent,\n rootID,\n transaction,\n this._mergeChildContext(context, childContext)\n );\n if (inst.componentDidMount) {\n transaction.getReactMountReady().enqueue(inst.componentDidMount, inst);\n }\n\n return markup;\n },\n\n /**\n * Releases any resources allocated by `mountComponent`.\n *\n * @final\n * @internal\n */\n unmountComponent: function() {\n var inst = this._instance;\n\n if (inst.componentWillUnmount) {\n var previouslyUnmounting = ReactLifeCycle.currentlyUnmountingInstance;\n ReactLifeCycle.currentlyUnmountingInstance = this;\n try {\n inst.componentWillUnmount();\n } finally {\n ReactLifeCycle.currentlyUnmountingInstance = previouslyUnmounting;\n }\n }\n\n ReactReconciler.unmountComponent(this._renderedComponent);\n this._renderedComponent = null;\n\n // Reset pending fields\n this._pendingStateQueue = null;\n this._pendingReplaceState = false;\n this._pendingForceUpdate = false;\n this._pendingCallbacks = null;\n this._pendingElement = null;\n\n // These fields do not really need to be reset since this object is no\n // longer accessible.\n this._context = null;\n this._rootNodeID = null;\n\n // Delete the reference from the instance to this internal representation\n // which allow the internals to be properly cleaned up even if the user\n // leaks a reference to the public instance.\n ReactInstanceMap.remove(inst);\n\n // Some existing components rely on inst.props even after they've been\n // destroyed (in event handlers).\n // TODO: inst.props = null;\n // TODO: inst.state = null;\n // TODO: inst.context = null;\n },\n\n /**\n * Schedule a partial update to the props. Only used for internal testing.\n *\n * @param {object} partialProps Subset of the next props.\n * @param {?function} callback Called after props are updated.\n * @final\n * @internal\n */\n _setPropsInternal: function(partialProps, callback) {\n // This is a deoptimized path. We optimize for always having an element.\n // This creates an extra internal element.\n var element = this._pendingElement || this._currentElement;\n this._pendingElement = ReactElement.cloneAndReplaceProps(\n element,\n assign({}, element.props, partialProps)\n );\n ReactUpdates.enqueueUpdate(this, callback);\n },\n\n /**\n * Filters the context object to only contain keys specified in\n * `contextTypes`\n *\n * @param {object} context\n * @return {?object}\n * @private\n */\n _maskContext: function(context) {\n var maskedContext = null;\n // This really should be getting the component class for the element,\n // but we know that we're not going to need it for built-ins.\n if (typeof this._currentElement.type === 'string') {\n return emptyObject;\n }\n var contextTypes = this._currentElement.type.contextTypes;\n if (!contextTypes) {\n return emptyObject;\n }\n maskedContext = {};\n for (var contextName in contextTypes) {\n maskedContext[contextName] = context[contextName];\n }\n return maskedContext;\n },\n\n /**\n * Filters the context object to only contain keys specified in\n * `contextTypes`, and asserts that they are valid.\n *\n * @param {object} context\n * @return {?object}\n * @private\n */\n _processContext: function(context) {\n var maskedContext = this._maskContext(context);\n if (\"production\" !== process.env.NODE_ENV) {\n var Component = ReactNativeComponent.getComponentClassForElement(\n this._currentElement\n );\n if (Component.contextTypes) {\n this._checkPropTypes(\n Component.contextTypes,\n maskedContext,\n ReactPropTypeLocations.context\n );\n }\n }\n return maskedContext;\n },\n\n /**\n * @param {object} currentContext\n * @return {object}\n * @private\n */\n _getValidatedChildContext: function(currentContext) {\n var inst = this._instance;\n var childContext = inst.getChildContext && inst.getChildContext();\n if (childContext) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n typeof inst.constructor.childContextTypes === 'object',\n '%s.getChildContext(): childContextTypes must be defined in order to ' +\n 'use getChildContext().',\n this.getName() || 'ReactCompositeComponent'\n ) : invariant(typeof inst.constructor.childContextTypes === 'object'));\n if (\"production\" !== process.env.NODE_ENV) {\n this._checkPropTypes(\n inst.constructor.childContextTypes,\n childContext,\n ReactPropTypeLocations.childContext\n );\n }\n for (var name in childContext) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n name in inst.constructor.childContextTypes,\n '%s.getChildContext(): key \"%s\" is not defined in childContextTypes.',\n this.getName() || 'ReactCompositeComponent',\n name\n ) : invariant(name in inst.constructor.childContextTypes));\n }\n return childContext;\n }\n return null;\n },\n\n _mergeChildContext: function(currentContext, childContext) {\n if (childContext) {\n return assign({}, currentContext, childContext);\n }\n return currentContext;\n },\n\n /**\n * Processes props by setting default values for unspecified props and\n * asserting that the props are valid. Does not mutate its argument; returns\n * a new props object with defaults merged in.\n *\n * @param {object} newProps\n * @return {object}\n * @private\n */\n _processProps: function(newProps) {\n if (\"production\" !== process.env.NODE_ENV) {\n var Component = ReactNativeComponent.getComponentClassForElement(\n this._currentElement\n );\n if (Component.propTypes) {\n this._checkPropTypes(\n Component.propTypes,\n newProps,\n ReactPropTypeLocations.prop\n );\n }\n }\n return newProps;\n },\n\n /**\n * Assert that the props are valid\n *\n * @param {object} propTypes Map of prop name to a ReactPropType\n * @param {object} props\n * @param {string} location e.g. \"prop\", \"context\", \"child context\"\n * @private\n */\n _checkPropTypes: function(propTypes, props, location) {\n // TODO: Stop validating prop types here and only use the element\n // validation.\n var componentName = this.getName();\n for (var propName in propTypes) {\n if (propTypes.hasOwnProperty(propName)) {\n var error;\n try {\n // This is intentionally an invariant that gets caught. It's the same\n // behavior as without this statement except with a better message.\n (\"production\" !== process.env.NODE_ENV ? invariant(\n typeof propTypes[propName] === 'function',\n '%s: %s type `%s` is invalid; it must be a function, usually ' +\n 'from React.PropTypes.',\n componentName || 'React class',\n ReactPropTypeLocationNames[location],\n propName\n ) : invariant(typeof propTypes[propName] === 'function'));\n error = propTypes[propName](props, propName, componentName, location);\n } catch (ex) {\n error = ex;\n }\n if (error instanceof Error) {\n // We may want to extend this logic for similar errors in\n // React.render calls, so I'm abstracting it away into\n // a function to minimize refactoring in the future\n var addendum = getDeclarationErrorAddendum(this);\n\n if (location === ReactPropTypeLocations.prop) {\n // Preface gives us something to blacklist in warning module\n (\"production\" !== process.env.NODE_ENV ? warning(\n false,\n 'Failed Composite propType: %s%s',\n error.message,\n addendum\n ) : null);\n } else {\n (\"production\" !== process.env.NODE_ENV ? warning(\n false,\n 'Failed Context Types: %s%s',\n error.message,\n addendum\n ) : null);\n }\n }\n }\n }\n },\n\n receiveComponent: function(nextElement, transaction, nextContext) {\n var prevElement = this._currentElement;\n var prevContext = this._context;\n\n this._pendingElement = null;\n\n this.updateComponent(\n transaction,\n prevElement,\n nextElement,\n prevContext,\n nextContext\n );\n },\n\n /**\n * If any of `_pendingElement`, `_pendingStateQueue`, or `_pendingForceUpdate`\n * is set, update the component.\n *\n * @param {ReactReconcileTransaction} transaction\n * @internal\n */\n performUpdateIfNecessary: function(transaction) {\n if (this._pendingElement != null) {\n ReactReconciler.receiveComponent(\n this,\n this._pendingElement || this._currentElement,\n transaction,\n this._context\n );\n }\n\n if (this._pendingStateQueue !== null || this._pendingForceUpdate) {\n if (\"production\" !== process.env.NODE_ENV) {\n ReactElementValidator.checkAndWarnForMutatedProps(\n this._currentElement\n );\n }\n\n this.updateComponent(\n transaction,\n this._currentElement,\n this._currentElement,\n this._context,\n this._context\n );\n }\n },\n\n /**\n * Compare two contexts, warning if they are different\n * TODO: Remove this check when owner-context is removed\n */\n _warnIfContextsDiffer: function(ownerBasedContext, parentBasedContext) {\n ownerBasedContext = this._maskContext(ownerBasedContext);\n parentBasedContext = this._maskContext(parentBasedContext);\n var parentKeys = Object.keys(parentBasedContext).sort();\n var displayName = this.getName() || 'ReactCompositeComponent';\n for (var i = 0; i < parentKeys.length; i++) {\n var key = parentKeys[i];\n (\"production\" !== process.env.NODE_ENV ? warning(\n ownerBasedContext[key] === parentBasedContext[key],\n 'owner-based and parent-based contexts differ ' +\n '(values: `%s` vs `%s`) for key (%s) while mounting %s ' +\n '(see: http://fb.me/react-context-by-parent)',\n ownerBasedContext[key],\n parentBasedContext[key],\n key,\n displayName\n ) : null);\n }\n },\n\n /**\n * Perform an update to a mounted component. The componentWillReceiveProps and\n * shouldComponentUpdate methods are called, then (assuming the update isn't\n * skipped) the remaining update lifecycle methods are called and the DOM\n * representation is updated.\n *\n * By default, this implements React's rendering and reconciliation algorithm.\n * Sophisticated clients may wish to override this.\n *\n * @param {ReactReconcileTransaction} transaction\n * @param {ReactElement} prevParentElement\n * @param {ReactElement} nextParentElement\n * @internal\n * @overridable\n */\n updateComponent: function(\n transaction,\n prevParentElement,\n nextParentElement,\n prevUnmaskedContext,\n nextUnmaskedContext\n ) {\n var inst = this._instance;\n\n var nextContext = inst.context;\n var nextProps = inst.props;\n\n // Distinguish between a props update versus a simple state update\n if (prevParentElement !== nextParentElement) {\n nextContext = this._processContext(nextParentElement._context);\n nextProps = this._processProps(nextParentElement.props);\n\n if (\"production\" !== process.env.NODE_ENV) {\n if (nextUnmaskedContext != null) {\n this._warnIfContextsDiffer(\n nextParentElement._context,\n nextUnmaskedContext\n );\n }\n }\n\n // An update here will schedule an update but immediately set\n // _pendingStateQueue which will ensure that any state updates gets\n // immediately reconciled instead of waiting for the next batch.\n\n if (inst.componentWillReceiveProps) {\n inst.componentWillReceiveProps(nextProps, nextContext);\n }\n }\n\n var nextState = this._processPendingState(nextProps, nextContext);\n\n var shouldUpdate =\n this._pendingForceUpdate ||\n !inst.shouldComponentUpdate ||\n inst.shouldComponentUpdate(nextProps, nextState, nextContext);\n\n if (\"production\" !== process.env.NODE_ENV) {\n (\"production\" !== process.env.NODE_ENV ? warning(\n typeof shouldUpdate !== 'undefined',\n '%s.shouldComponentUpdate(): Returned undefined instead of a ' +\n 'boolean value. Make sure to return true or false.',\n this.getName() || 'ReactCompositeComponent'\n ) : null);\n }\n\n if (shouldUpdate) {\n this._pendingForceUpdate = false;\n // Will set `this.props`, `this.state` and `this.context`.\n this._performComponentUpdate(\n nextParentElement,\n nextProps,\n nextState,\n nextContext,\n transaction,\n nextUnmaskedContext\n );\n } else {\n // If it's determined that a component should not update, we still want\n // to set props and state but we shortcut the rest of the update.\n this._currentElement = nextParentElement;\n this._context = nextUnmaskedContext;\n inst.props = nextProps;\n inst.state = nextState;\n inst.context = nextContext;\n }\n },\n\n _processPendingState: function(props, context) {\n var inst = this._instance;\n var queue = this._pendingStateQueue;\n var replace = this._pendingReplaceState;\n this._pendingReplaceState = false;\n this._pendingStateQueue = null;\n\n if (!queue) {\n return inst.state;\n }\n\n if (replace && queue.length === 1) {\n return queue[0];\n }\n\n var nextState = assign({}, replace ? queue[0] : inst.state);\n for (var i = replace ? 1 : 0; i < queue.length; i++) {\n var partial = queue[i];\n assign(\n nextState,\n typeof partial === 'function' ?\n partial.call(inst, nextState, props, context) :\n partial\n );\n }\n\n return nextState;\n },\n\n /**\n * Merges new props and state, notifies delegate methods of update and\n * performs update.\n *\n * @param {ReactElement} nextElement Next element\n * @param {object} nextProps Next public object to set as properties.\n * @param {?object} nextState Next object to set as state.\n * @param {?object} nextContext Next public object to set as context.\n * @param {ReactReconcileTransaction} transaction\n * @param {?object} unmaskedContext\n * @private\n */\n _performComponentUpdate: function(\n nextElement,\n nextProps,\n nextState,\n nextContext,\n transaction,\n unmaskedContext\n ) {\n var inst = this._instance;\n\n var prevProps = inst.props;\n var prevState = inst.state;\n var prevContext = inst.context;\n\n if (inst.componentWillUpdate) {\n inst.componentWillUpdate(nextProps, nextState, nextContext);\n }\n\n this._currentElement = nextElement;\n this._context = unmaskedContext;\n inst.props = nextProps;\n inst.state = nextState;\n inst.context = nextContext;\n\n this._updateRenderedComponent(transaction, unmaskedContext);\n\n if (inst.componentDidUpdate) {\n transaction.getReactMountReady().enqueue(\n inst.componentDidUpdate.bind(inst, prevProps, prevState, prevContext),\n inst\n );\n }\n },\n\n /**\n * Call the component's `render` method and update the DOM accordingly.\n *\n * @param {ReactReconcileTransaction} transaction\n * @internal\n */\n _updateRenderedComponent: function(transaction, context) {\n var prevComponentInstance = this._renderedComponent;\n var prevRenderedElement = prevComponentInstance._currentElement;\n var childContext = this._getValidatedChildContext();\n var nextRenderedElement = this._renderValidatedComponent(childContext);\n if (shouldUpdateReactComponent(prevRenderedElement, nextRenderedElement)) {\n ReactReconciler.receiveComponent(\n prevComponentInstance,\n nextRenderedElement,\n transaction,\n this._mergeChildContext(context, childContext)\n );\n } else {\n // These two IDs are actually the same! But nothing should rely on that.\n var thisID = this._rootNodeID;\n var prevComponentID = prevComponentInstance._rootNodeID;\n ReactReconciler.unmountComponent(prevComponentInstance);\n\n this._renderedComponent = this._instantiateReactComponent(\n nextRenderedElement,\n this._currentElement.type\n );\n var nextMarkup = ReactReconciler.mountComponent(\n this._renderedComponent,\n thisID,\n transaction,\n this._mergeChildContext(context, childContext)\n );\n this._replaceNodeWithMarkupByID(prevComponentID, nextMarkup);\n }\n },\n\n /**\n * @protected\n */\n _replaceNodeWithMarkupByID: function(prevComponentID, nextMarkup) {\n ReactComponentEnvironment.replaceNodeWithMarkupByID(\n prevComponentID,\n nextMarkup\n );\n },\n\n /**\n * @protected\n */\n _renderValidatedComponentWithoutOwnerOrContext: function() {\n var inst = this._instance;\n var renderedComponent = inst.render();\n if (\"production\" !== process.env.NODE_ENV) {\n // We allow auto-mocks to proceed as if they're returning null.\n if (typeof renderedComponent === 'undefined' &&\n inst.render._isMockFunction) {\n // This is probably bad practice. Consider warning here and\n // deprecating this convenience.\n renderedComponent = null;\n }\n }\n\n return renderedComponent;\n },\n\n /**\n * @private\n */\n _renderValidatedComponent: function(childContext) {\n var renderedComponent;\n var previousContext = ReactContext.current;\n ReactContext.current = this._mergeChildContext(\n this._currentElement._context,\n childContext\n );\n ReactCurrentOwner.current = this;\n try {\n renderedComponent =\n this._renderValidatedComponentWithoutOwnerOrContext();\n } finally {\n ReactContext.current = previousContext;\n ReactCurrentOwner.current = null;\n }\n (\"production\" !== process.env.NODE_ENV ? invariant(\n // TODO: An `isValidNode` function would probably be more appropriate\n renderedComponent === null || renderedComponent === false ||\n ReactElement.isValidElement(renderedComponent),\n '%s.render(): A valid ReactComponent must be returned. You may have ' +\n 'returned undefined, an array or some other invalid object.',\n this.getName() || 'ReactCompositeComponent'\n ) : invariant(// TODO: An `isValidNode` function would probably be more appropriate\n renderedComponent === null || renderedComponent === false ||\n ReactElement.isValidElement(renderedComponent)));\n return renderedComponent;\n },\n\n /**\n * Lazily allocates the refs object and stores `component` as `ref`.\n *\n * @param {string} ref Reference name.\n * @param {component} component Component to store as `ref`.\n * @final\n * @private\n */\n attachRef: function(ref, component) {\n var inst = this.getPublicInstance();\n var refs = inst.refs === emptyObject ? (inst.refs = {}) : inst.refs;\n refs[ref] = component.getPublicInstance();\n },\n\n /**\n * Detaches a reference name.\n *\n * @param {string} ref Name to dereference.\n * @final\n * @private\n */\n detachRef: function(ref) {\n var refs = this.getPublicInstance().refs;\n delete refs[ref];\n },\n\n /**\n * Get a text description of the component that can be used to identify it\n * in error messages.\n * @return {string} The name or null.\n * @internal\n */\n getName: function() {\n var type = this._currentElement.type;\n var constructor = this._instance && this._instance.constructor;\n return (\n type.displayName || (constructor && constructor.displayName) ||\n type.name || (constructor && constructor.name) ||\n null\n );\n },\n\n /**\n * Get the publicly accessible representation of this component - i.e. what\n * is exposed by refs and returned by React.render. Can be null for stateless\n * components.\n *\n * @return {ReactComponent} the public component instance.\n * @internal\n */\n getPublicInstance: function() {\n return this._instance;\n },\n\n // Stub\n _instantiateReactComponent: null\n\n};\n\nReactPerf.measureMethods(\n ReactCompositeComponentMixin,\n 'ReactCompositeComponent',\n {\n mountComponent: 'mountComponent',\n updateComponent: 'updateComponent',\n _renderValidatedComponent: '_renderValidatedComponent'\n }\n);\n\nvar ReactCompositeComponent = {\n\n Mixin: ReactCompositeComponentMixin\n\n};\n\nmodule.exports = ReactCompositeComponent;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactCompositeComponent.js\n ** module id = 111\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ReactCompositeComponent.js?");
|
||
|
||
/***/ },
|
||
/* 112 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/* WEBPACK VAR INJECTION */(function(process) {/**\n * Copyright 2014-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 ReactComponentEnvironment\n */\n\n'use strict';\n\nvar invariant = __webpack_require__(64);\n\nvar injected = false;\n\nvar ReactComponentEnvironment = {\n\n /**\n * Optionally injectable environment dependent cleanup hook. (server vs.\n * browser etc). Example: A browser system caches DOM nodes based on component\n * ID and must remove that cache entry when this instance is unmounted.\n */\n unmountIDFromEnvironment: null,\n\n /**\n * Optionally injectable hook for swapping out mount images in the middle of\n * the tree.\n */\n replaceNodeWithMarkupByID: null,\n\n /**\n * Optionally injectable hook for processing a queue of child updates. Will\n * later move into MultiChildComponents.\n */\n processChildrenUpdates: null,\n\n injection: {\n injectEnvironment: function(environment) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n !injected,\n 'ReactCompositeComponent: injectEnvironment() can only be called once.'\n ) : invariant(!injected));\n ReactComponentEnvironment.unmountIDFromEnvironment =\n environment.unmountIDFromEnvironment;\n ReactComponentEnvironment.replaceNodeWithMarkupByID =\n environment.replaceNodeWithMarkupByID;\n ReactComponentEnvironment.processChildrenUpdates =\n environment.processChildrenUpdates;\n injected = true;\n }\n }\n\n};\n\nmodule.exports = ReactComponentEnvironment;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactComponentEnvironment.js\n ** module id = 112\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ReactComponentEnvironment.js?");
|
||
|
||
/***/ },
|
||
/* 113 */
|
||
/***/ 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 shouldUpdateReactComponent\n * @typechecks static-only\n */\n\n'use strict';\n\nvar warning = __webpack_require__(82);\n\n/**\n * Given a `prevElement` and `nextElement`, determines if the existing\n * instance should be updated as opposed to being destroyed or replaced by a new\n * instance. Both arguments are elements. This ensures that this logic can\n * operate on stateless trees without any backing instance.\n *\n * @param {?object} prevElement\n * @param {?object} nextElement\n * @return {boolean} True if the existing instance should be updated.\n * @protected\n */\nfunction shouldUpdateReactComponent(prevElement, nextElement) {\n if (prevElement != null && nextElement != null) {\n var prevType = typeof prevElement;\n var nextType = typeof nextElement;\n if (prevType === 'string' || prevType === 'number') {\n return (nextType === 'string' || nextType === 'number');\n } else {\n if (nextType === 'object' &&\n prevElement.type === nextElement.type &&\n prevElement.key === nextElement.key) {\n var ownersMatch = prevElement._owner === nextElement._owner;\n var prevName = null;\n var nextName = null;\n var nextDisplayName = null;\n if (\"production\" !== process.env.NODE_ENV) {\n if (!ownersMatch) {\n if (prevElement._owner != null &&\n prevElement._owner.getPublicInstance() != null &&\n prevElement._owner.getPublicInstance().constructor != null) {\n prevName =\n prevElement._owner.getPublicInstance().constructor.displayName;\n }\n if (nextElement._owner != null &&\n nextElement._owner.getPublicInstance() != null &&\n nextElement._owner.getPublicInstance().constructor != null) {\n nextName =\n nextElement._owner.getPublicInstance().constructor.displayName;\n }\n if (nextElement.type != null &&\n nextElement.type.displayName != null) {\n nextDisplayName = nextElement.type.displayName;\n }\n if (nextElement.type != null && typeof nextElement.type === 'string') {\n nextDisplayName = nextElement.type;\n }\n if (typeof nextElement.type !== 'string' ||\n nextElement.type === 'input' ||\n nextElement.type === 'textarea') {\n if ((prevElement._owner != null &&\n prevElement._owner._isOwnerNecessary === false) ||\n (nextElement._owner != null &&\n nextElement._owner._isOwnerNecessary === false)) {\n if (prevElement._owner != null) {\n prevElement._owner._isOwnerNecessary = true;\n }\n if (nextElement._owner != null) {\n nextElement._owner._isOwnerNecessary = true;\n }\n (\"production\" !== process.env.NODE_ENV ? warning(\n false,\n '<%s /> is being rendered by both %s and %s using the same ' +\n 'key (%s) in the same place. Currently, this means that ' +\n 'they don\\'t preserve state. This behavior should be very ' +\n 'rare so we\\'re considering deprecating it. Please contact ' +\n 'the React team and explain your use case so that we can ' +\n 'take that into consideration.',\n nextDisplayName || 'Unknown Component',\n prevName || '[Unknown]',\n nextName || '[Unknown]',\n prevElement.key\n ) : null);\n }\n }\n }\n }\n return ownersMatch;\n }\n }\n }\n return false;\n}\n\nmodule.exports = shouldUpdateReactComponent;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/shouldUpdateReactComponent.js\n ** module id = 113\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/shouldUpdateReactComponent.js?");
|
||
|
||
/***/ },
|
||
/* 114 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\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 setInnerHTML\n */\n\n/* globals MSApp */\n\n'use strict';\n\nvar ExecutionEnvironment = __webpack_require__(77);\n\nvar WHITESPACE_TEST = /^[ \\r\\n\\t\\f]/;\nvar NONVISIBLE_TEST = /<(!--|link|noscript|meta|script|style)[ \\r\\n\\t\\f\\/>]/;\n\n/**\n * Set the innerHTML property of a node, ensuring that whitespace is preserved\n * even in IE8.\n *\n * @param {DOMElement} node\n * @param {string} html\n * @internal\n */\nvar setInnerHTML = function(node, html) {\n node.innerHTML = html;\n};\n\n// Win8 apps: Allow all html to be inserted\nif (typeof MSApp !== 'undefined' && MSApp.execUnsafeLocalFunction) {\n setInnerHTML = function(node, html) {\n MSApp.execUnsafeLocalFunction(function() {\n node.innerHTML = html;\n });\n };\n}\n\nif (ExecutionEnvironment.canUseDOM) {\n // IE8: When updating a just created node with innerHTML only leading\n // whitespace is removed. When updating an existing node with innerHTML\n // whitespace in root TextNodes is also collapsed.\n // @see quirksmode.org/bugreports/archives/2004/11/innerhtml_and_t.html\n\n // Feature detection; only IE8 is known to behave improperly like this.\n var testElement = document.createElement('div');\n testElement.innerHTML = ' ';\n if (testElement.innerHTML === '') {\n setInnerHTML = function(node, html) {\n // Magic theory: IE8 supposedly differentiates between added and updated\n // nodes when processing innerHTML, innerHTML on updated nodes suffers\n // from worse whitespace behavior. Re-adding a node like this triggers\n // the initial and more favorable whitespace behavior.\n // TODO: What to do on a detached node?\n if (node.parentNode) {\n node.parentNode.replaceChild(node, node);\n }\n\n // We also implement a workaround for non-visible tags disappearing into\n // thin air on IE8, this only happens if there is no visible text\n // in-front of the non-visible tags. Piggyback on the whitespace fix\n // and simply check if any non-visible tags appear in the source.\n if (WHITESPACE_TEST.test(html) ||\n html[0] === '<' && NONVISIBLE_TEST.test(html)) {\n // Recover leading whitespace by temporarily prepending any character.\n // \\uFEFF has the potential advantage of being zero-width/invisible.\n node.innerHTML = '\\uFEFF' + html;\n\n // deleteData leaves an empty `TextNode` which offsets the index of all\n // children. Definitely want to avoid this.\n var textNode = node.firstChild;\n if (textNode.data.length === 1) {\n node.removeChild(textNode);\n } else {\n textNode.deleteData(0, 1);\n }\n } else {\n node.innerHTML = html;\n }\n };\n }\n}\n\nmodule.exports = setInnerHTML;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/setInnerHTML.js\n ** module id = 114\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/setInnerHTML.js?");
|
||
|
||
/***/ },
|
||
/* 115 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("module.exports = __webpack_require__(116);\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/react.js\n ** module id = 115\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/react.js?");
|
||
|
||
/***/ },
|
||
/* 116 */
|
||
/***/ 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 React\n */\n\n/* globals __REACT_DEVTOOLS_GLOBAL_HOOK__*/\n\n'use strict';\n\nvar EventPluginUtils = __webpack_require__(70);\nvar ReactChildren = __webpack_require__(117);\nvar ReactComponent = __webpack_require__(119);\nvar ReactClass = __webpack_require__(120);\nvar ReactContext = __webpack_require__(80);\nvar ReactCurrentOwner = __webpack_require__(78);\nvar ReactElement = __webpack_require__(79);\nvar ReactElementValidator = __webpack_require__(84);\nvar ReactDOM = __webpack_require__(123);\nvar ReactDOMTextComponent = __webpack_require__(125);\nvar ReactDefaultInjection = __webpack_require__(151);\nvar ReactInstanceHandles = __webpack_require__(92);\nvar ReactMount = __webpack_require__(61);\nvar ReactPerf = __webpack_require__(96);\nvar ReactPropTypes = __webpack_require__(182);\nvar ReactReconciler = __webpack_require__(97);\nvar ReactServerRendering = __webpack_require__(214);\n\nvar assign = __webpack_require__(75);\nvar findDOMNode = __webpack_require__(171);\nvar onlyChild = __webpack_require__(216);\n\nReactDefaultInjection.inject();\n\nvar createElement = ReactElement.createElement;\nvar createFactory = ReactElement.createFactory;\nvar cloneElement = ReactElement.cloneElement;\n\nif (\"production\" !== process.env.NODE_ENV) {\n createElement = ReactElementValidator.createElement;\n createFactory = ReactElementValidator.createFactory;\n cloneElement = ReactElementValidator.cloneElement;\n}\n\nvar render = ReactPerf.measure('React', 'render', ReactMount.render);\n\nvar React = {\n Children: {\n map: ReactChildren.map,\n forEach: ReactChildren.forEach,\n count: ReactChildren.count,\n only: onlyChild\n },\n Component: ReactComponent,\n DOM: ReactDOM,\n PropTypes: ReactPropTypes,\n initializeTouchEvents: function(shouldUseTouch) {\n EventPluginUtils.useTouchEvents = shouldUseTouch;\n },\n createClass: ReactClass.createClass,\n createElement: createElement,\n cloneElement: cloneElement,\n createFactory: createFactory,\n createMixin: function(mixin) {\n // Currently a noop. Will be used to validate and trace mixins.\n return mixin;\n },\n constructAndRenderComponent: ReactMount.constructAndRenderComponent,\n constructAndRenderComponentByID: ReactMount.constructAndRenderComponentByID,\n findDOMNode: findDOMNode,\n render: render,\n renderToString: ReactServerRendering.renderToString,\n renderToStaticMarkup: ReactServerRendering.renderToStaticMarkup,\n unmountComponentAtNode: ReactMount.unmountComponentAtNode,\n isValidElement: ReactElement.isValidElement,\n withContext: ReactContext.withContext,\n\n // Hook for JSX spread, don't use this for anything else.\n __spread: assign\n};\n\n// Inject the runtime into a devtools global hook regardless of browser.\n// Allows for debugging when the hook is injected on the page.\nif (\n typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' &&\n typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.inject === 'function') {\n __REACT_DEVTOOLS_GLOBAL_HOOK__.inject({\n CurrentOwner: ReactCurrentOwner,\n InstanceHandles: ReactInstanceHandles,\n Mount: ReactMount,\n Reconciler: ReactReconciler,\n TextComponent: ReactDOMTextComponent\n });\n}\n\nif (\"production\" !== process.env.NODE_ENV) {\n var ExecutionEnvironment = __webpack_require__(77);\n if (ExecutionEnvironment.canUseDOM && window.top === window.self) {\n\n // If we're in Chrome, look for the devtools marker and provide a download\n // link if not installed.\n if (navigator.userAgent.indexOf('Chrome') > -1) {\n if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ === 'undefined') {\n console.debug(\n 'Download the React DevTools for a better development experience: ' +\n 'https://fb.me/react-devtools'\n );\n }\n }\n\n var expectedFeatures = [\n // shims\n Array.isArray,\n Array.prototype.every,\n Array.prototype.forEach,\n Array.prototype.indexOf,\n Array.prototype.map,\n Date.now,\n Function.prototype.bind,\n Object.keys,\n String.prototype.split,\n String.prototype.trim,\n\n // shams\n Object.create,\n Object.freeze\n ];\n\n for (var i = 0; i < expectedFeatures.length; i++) {\n if (!expectedFeatures[i]) {\n console.error(\n 'One or more ES5 shim/shams expected by React are not available: ' +\n 'https://fb.me/react-warning-polyfills'\n );\n break;\n }\n }\n }\n}\n\nReact.version = '0.13.3';\n\nmodule.exports = React;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/React.js\n ** module id = 116\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/React.js?");
|
||
|
||
/***/ },
|
||
/* 117 */
|
||
/***/ 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 ReactChildren\n */\n\n'use strict';\n\nvar PooledClass = __webpack_require__(103);\nvar ReactFragment = __webpack_require__(85);\n\nvar traverseAllChildren = __webpack_require__(118);\nvar warning = __webpack_require__(82);\n\nvar twoArgumentPooler = PooledClass.twoArgumentPooler;\nvar threeArgumentPooler = PooledClass.threeArgumentPooler;\n\n/**\n * PooledClass representing the bookkeeping associated with performing a child\n * traversal. Allows avoiding binding callbacks.\n *\n * @constructor ForEachBookKeeping\n * @param {!function} forEachFunction Function to perform traversal with.\n * @param {?*} forEachContext Context to perform context with.\n */\nfunction ForEachBookKeeping(forEachFunction, forEachContext) {\n this.forEachFunction = forEachFunction;\n this.forEachContext = forEachContext;\n}\nPooledClass.addPoolingTo(ForEachBookKeeping, twoArgumentPooler);\n\nfunction forEachSingleChild(traverseContext, child, name, i) {\n var forEachBookKeeping = traverseContext;\n forEachBookKeeping.forEachFunction.call(\n forEachBookKeeping.forEachContext, child, i);\n}\n\n/**\n * Iterates through children that are typically specified as `props.children`.\n *\n * The provided forEachFunc(child, index) will be called for each\n * leaf child.\n *\n * @param {?*} children Children tree container.\n * @param {function(*, int)} forEachFunc.\n * @param {*} forEachContext Context for forEachContext.\n */\nfunction forEachChildren(children, forEachFunc, forEachContext) {\n if (children == null) {\n return children;\n }\n\n var traverseContext =\n ForEachBookKeeping.getPooled(forEachFunc, forEachContext);\n traverseAllChildren(children, forEachSingleChild, traverseContext);\n ForEachBookKeeping.release(traverseContext);\n}\n\n/**\n * PooledClass representing the bookkeeping associated with performing a child\n * mapping. Allows avoiding binding callbacks.\n *\n * @constructor MapBookKeeping\n * @param {!*} mapResult Object containing the ordered map of results.\n * @param {!function} mapFunction Function to perform mapping with.\n * @param {?*} mapContext Context to perform mapping with.\n */\nfunction MapBookKeeping(mapResult, mapFunction, mapContext) {\n this.mapResult = mapResult;\n this.mapFunction = mapFunction;\n this.mapContext = mapContext;\n}\nPooledClass.addPoolingTo(MapBookKeeping, threeArgumentPooler);\n\nfunction mapSingleChildIntoContext(traverseContext, child, name, i) {\n var mapBookKeeping = traverseContext;\n var mapResult = mapBookKeeping.mapResult;\n\n var keyUnique = !mapResult.hasOwnProperty(name);\n if (\"production\" !== process.env.NODE_ENV) {\n (\"production\" !== process.env.NODE_ENV ? warning(\n keyUnique,\n 'ReactChildren.map(...): Encountered two children with the same key, ' +\n '`%s`. Child keys must be unique; when two children share a key, only ' +\n 'the first child will be used.',\n name\n ) : null);\n }\n\n if (keyUnique) {\n var mappedChild =\n mapBookKeeping.mapFunction.call(mapBookKeeping.mapContext, child, i);\n mapResult[name] = mappedChild;\n }\n}\n\n/**\n * Maps children that are typically specified as `props.children`.\n *\n * The provided mapFunction(child, key, index) will be called for each\n * leaf child.\n *\n * TODO: This may likely break any calls to `ReactChildren.map` that were\n * previously relying on the fact that we guarded against null children.\n *\n * @param {?*} children Children tree container.\n * @param {function(*, int)} mapFunction.\n * @param {*} mapContext Context for mapFunction.\n * @return {object} Object containing the ordered map of results.\n */\nfunction mapChildren(children, func, context) {\n if (children == null) {\n return children;\n }\n\n var mapResult = {};\n var traverseContext = MapBookKeeping.getPooled(mapResult, func, context);\n traverseAllChildren(children, mapSingleChildIntoContext, traverseContext);\n MapBookKeeping.release(traverseContext);\n return ReactFragment.create(mapResult);\n}\n\nfunction forEachSingleChildDummy(traverseContext, child, name, i) {\n return null;\n}\n\n/**\n * Count the number of children that are typically specified as\n * `props.children`.\n *\n * @param {?*} children Children tree container.\n * @return {number} The number of children.\n */\nfunction countChildren(children, context) {\n return traverseAllChildren(children, forEachSingleChildDummy, null);\n}\n\nvar ReactChildren = {\n forEach: forEachChildren,\n map: mapChildren,\n count: countChildren\n};\n\nmodule.exports = ReactChildren;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactChildren.js\n ** module id = 117\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ReactChildren.js?");
|
||
|
||
/***/ },
|
||
/* 118 */
|
||
/***/ 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 traverseAllChildren\n */\n\n'use strict';\n\nvar ReactElement = __webpack_require__(79);\nvar ReactFragment = __webpack_require__(85);\nvar ReactInstanceHandles = __webpack_require__(92);\n\nvar getIteratorFn = __webpack_require__(89);\nvar invariant = __webpack_require__(64);\nvar warning = __webpack_require__(82);\n\nvar SEPARATOR = ReactInstanceHandles.SEPARATOR;\nvar SUBSEPARATOR = ':';\n\n/**\n * TODO: Test that a single child and an array with one item have the same key\n * pattern.\n */\n\nvar userProvidedKeyEscaperLookup = {\n '=': '=0',\n '.': '=1',\n ':': '=2'\n};\n\nvar userProvidedKeyEscapeRegex = /[=.:]/g;\n\nvar didWarnAboutMaps = false;\n\nfunction userProvidedKeyEscaper(match) {\n return userProvidedKeyEscaperLookup[match];\n}\n\n/**\n * Generate a key string that identifies a component within a set.\n *\n * @param {*} component A component that could contain a manual key.\n * @param {number} index Index that is used if a manual key is not provided.\n * @return {string}\n */\nfunction getComponentKey(component, index) {\n if (component && component.key != null) {\n // Explicit key\n return wrapUserProvidedKey(component.key);\n }\n // Implicit key determined by the index in the set\n return index.toString(36);\n}\n\n/**\n * Escape a component key so that it is safe to use in a reactid.\n *\n * @param {*} key Component key to be escaped.\n * @return {string} An escaped string.\n */\nfunction escapeUserProvidedKey(text) {\n return ('' + text).replace(\n userProvidedKeyEscapeRegex,\n userProvidedKeyEscaper\n );\n}\n\n/**\n * Wrap a `key` value explicitly provided by the user to distinguish it from\n * implicitly-generated keys generated by a component's index in its parent.\n *\n * @param {string} key Value of a user-provided `key` attribute\n * @return {string}\n */\nfunction wrapUserProvidedKey(key) {\n return '$' + escapeUserProvidedKey(key);\n}\n\n/**\n * @param {?*} children Children tree container.\n * @param {!string} nameSoFar Name of the key path so far.\n * @param {!number} indexSoFar Number of children encountered until this point.\n * @param {!function} callback Callback to invoke with each child found.\n * @param {?*} traverseContext Used to pass information throughout the traversal\n * process.\n * @return {!number} The number of children in this subtree.\n */\nfunction traverseAllChildrenImpl(\n children,\n nameSoFar,\n indexSoFar,\n callback,\n traverseContext\n) {\n var type = typeof children;\n\n if (type === 'undefined' || type === 'boolean') {\n // All of the above are perceived as null.\n children = null;\n }\n\n if (children === null ||\n type === 'string' ||\n type === 'number' ||\n ReactElement.isValidElement(children)) {\n callback(\n traverseContext,\n children,\n // If it's the only child, treat the name as if it was wrapped in an array\n // so that it's consistent if the number of children grows.\n nameSoFar === '' ? SEPARATOR + getComponentKey(children, 0) : nameSoFar,\n indexSoFar\n );\n return 1;\n }\n\n var child, nextName, nextIndex;\n var subtreeCount = 0; // Count of children found in the current subtree.\n\n if (Array.isArray(children)) {\n for (var i = 0; i < children.length; i++) {\n child = children[i];\n nextName = (\n (nameSoFar !== '' ? nameSoFar + SUBSEPARATOR : SEPARATOR) +\n getComponentKey(child, i)\n );\n nextIndex = indexSoFar + subtreeCount;\n subtreeCount += traverseAllChildrenImpl(\n child,\n nextName,\n nextIndex,\n callback,\n traverseContext\n );\n }\n } else {\n var iteratorFn = getIteratorFn(children);\n if (iteratorFn) {\n var iterator = iteratorFn.call(children);\n var step;\n if (iteratorFn !== children.entries) {\n var ii = 0;\n while (!(step = iterator.next()).done) {\n child = step.value;\n nextName = (\n (nameSoFar !== '' ? nameSoFar + SUBSEPARATOR : SEPARATOR) +\n getComponentKey(child, ii++)\n );\n nextIndex = indexSoFar + subtreeCount;\n subtreeCount += traverseAllChildrenImpl(\n child,\n nextName,\n nextIndex,\n callback,\n traverseContext\n );\n }\n } else {\n if (\"production\" !== process.env.NODE_ENV) {\n (\"production\" !== process.env.NODE_ENV ? warning(\n didWarnAboutMaps,\n 'Using Maps as children is not yet fully supported. It is an ' +\n 'experimental feature that might be removed. Convert it to a ' +\n 'sequence / iterable of keyed ReactElements instead.'\n ) : null);\n didWarnAboutMaps = true;\n }\n // Iterator will provide entry [k,v] tuples rather than values.\n while (!(step = iterator.next()).done) {\n var entry = step.value;\n if (entry) {\n child = entry[1];\n nextName = (\n (nameSoFar !== '' ? nameSoFar + SUBSEPARATOR : SEPARATOR) +\n wrapUserProvidedKey(entry[0]) + SUBSEPARATOR +\n getComponentKey(child, 0)\n );\n nextIndex = indexSoFar + subtreeCount;\n subtreeCount += traverseAllChildrenImpl(\n child,\n nextName,\n nextIndex,\n callback,\n traverseContext\n );\n }\n }\n }\n } else if (type === 'object') {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n children.nodeType !== 1,\n 'traverseAllChildren(...): Encountered an invalid child; DOM ' +\n 'elements are not valid children of React components.'\n ) : invariant(children.nodeType !== 1));\n var fragment = ReactFragment.extract(children);\n for (var key in fragment) {\n if (fragment.hasOwnProperty(key)) {\n child = fragment[key];\n nextName = (\n (nameSoFar !== '' ? nameSoFar + SUBSEPARATOR : SEPARATOR) +\n wrapUserProvidedKey(key) + SUBSEPARATOR +\n getComponentKey(child, 0)\n );\n nextIndex = indexSoFar + subtreeCount;\n subtreeCount += traverseAllChildrenImpl(\n child,\n nextName,\n nextIndex,\n callback,\n traverseContext\n );\n }\n }\n }\n }\n\n return subtreeCount;\n}\n\n/**\n * Traverses children that are typically specified as `props.children`, but\n * might also be specified through attributes:\n *\n * - `traverseAllChildren(this.props.children, ...)`\n * - `traverseAllChildren(this.props.leftPanelChildren, ...)`\n *\n * The `traverseContext` is an optional argument that is passed through the\n * entire traversal. It can be used to store accumulations or anything else that\n * the callback might find relevant.\n *\n * @param {?*} children Children tree object.\n * @param {!function} callback To invoke upon traversing each child.\n * @param {?*} traverseContext Context for traversal.\n * @return {!number} The number of children in this subtree.\n */\nfunction traverseAllChildren(children, callback, traverseContext) {\n if (children == null) {\n return 0;\n }\n\n return traverseAllChildrenImpl(children, '', 0, callback, traverseContext);\n}\n\nmodule.exports = traverseAllChildren;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/traverseAllChildren.js\n ** module id = 118\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/traverseAllChildren.js?");
|
||
|
||
/***/ },
|
||
/* 119 */
|
||
/***/ 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 ReactComponent\n */\n\n'use strict';\n\nvar ReactUpdateQueue = __webpack_require__(100);\n\nvar invariant = __webpack_require__(64);\nvar warning = __webpack_require__(82);\n\n/**\n * Base class helpers for the updating state of a component.\n */\nfunction ReactComponent(props, context) {\n this.props = props;\n this.context = context;\n}\n\n/**\n * Sets a subset of the state. Always use this to mutate\n * state. You should treat `this.state` as immutable.\n *\n * There is no guarantee that `this.state` will be immediately updated, so\n * accessing `this.state` after calling this method may return the old value.\n *\n * There is no guarantee that calls to `setState` will run synchronously,\n * as they may eventually be batched together. You can provide an optional\n * callback that will be executed when the call to setState is actually\n * completed.\n *\n * When a function is provided to setState, it will be called at some point in\n * the future (not synchronously). It will be called with the up to date\n * component arguments (state, props, context). These values can be different\n * from this.* because your function may be called after receiveProps but before\n * shouldComponentUpdate, and this new state, props, and context will not yet be\n * assigned to this.\n *\n * @param {object|function} partialState Next partial state or function to\n * produce next partial state to be merged with current state.\n * @param {?function} callback Called after state is updated.\n * @final\n * @protected\n */\nReactComponent.prototype.setState = function(partialState, callback) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n typeof partialState === 'object' ||\n typeof partialState === 'function' ||\n partialState == null,\n 'setState(...): takes an object of state variables to update or a ' +\n 'function which returns an object of state variables.'\n ) : invariant(typeof partialState === 'object' ||\n typeof partialState === 'function' ||\n partialState == null));\n if (\"production\" !== process.env.NODE_ENV) {\n (\"production\" !== process.env.NODE_ENV ? warning(\n partialState != null,\n 'setState(...): You passed an undefined or null state object; ' +\n 'instead, use forceUpdate().'\n ) : null);\n }\n ReactUpdateQueue.enqueueSetState(this, partialState);\n if (callback) {\n ReactUpdateQueue.enqueueCallback(this, callback);\n }\n};\n\n/**\n * Forces an update. This should only be invoked when it is known with\n * certainty that we are **not** in a DOM transaction.\n *\n * You may want to call this when you know that some deeper aspect of the\n * component's state has changed but `setState` was not called.\n *\n * This will not invoke `shouldComponentUpdate`, but it will invoke\n * `componentWillUpdate` and `componentDidUpdate`.\n *\n * @param {?function} callback Called after update is complete.\n * @final\n * @protected\n */\nReactComponent.prototype.forceUpdate = function(callback) {\n ReactUpdateQueue.enqueueForceUpdate(this);\n if (callback) {\n ReactUpdateQueue.enqueueCallback(this, callback);\n }\n};\n\n/**\n * Deprecated APIs. These APIs used to exist on classic React classes but since\n * we would like to deprecate them, we're not going to move them over to this\n * modern base class. Instead, we define a getter that warns if it's accessed.\n */\nif (\"production\" !== process.env.NODE_ENV) {\n var deprecatedAPIs = {\n getDOMNode: [\n 'getDOMNode',\n 'Use React.findDOMNode(component) instead.'\n ],\n isMounted: [\n 'isMounted',\n 'Instead, make sure to clean up subscriptions and pending requests in ' +\n 'componentWillUnmount to prevent memory leaks.'\n ],\n replaceProps: [\n 'replaceProps',\n 'Instead, call React.render again at the top level.'\n ],\n replaceState: [\n 'replaceState',\n 'Refactor your code to use setState instead (see ' +\n 'https://github.com/facebook/react/issues/3236).'\n ],\n setProps: [\n 'setProps',\n 'Instead, call React.render again at the top level.'\n ]\n };\n var defineDeprecationWarning = function(methodName, info) {\n try {\n Object.defineProperty(ReactComponent.prototype, methodName, {\n get: function() {\n (\"production\" !== process.env.NODE_ENV ? warning(\n false,\n '%s(...) is deprecated in plain JavaScript React classes. %s',\n info[0],\n info[1]\n ) : null);\n return undefined;\n }\n });\n } catch (x) {\n // IE will fail on defineProperty (es5-shim/sham too)\n }\n };\n for (var fnName in deprecatedAPIs) {\n if (deprecatedAPIs.hasOwnProperty(fnName)) {\n defineDeprecationWarning(fnName, deprecatedAPIs[fnName]);\n }\n }\n}\n\nmodule.exports = ReactComponent;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactComponent.js\n ** module id = 119\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ReactComponent.js?");
|
||
|
||
/***/ },
|
||
/* 120 */
|
||
/***/ 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 ReactClass\n */\n\n'use strict';\n\nvar ReactComponent = __webpack_require__(119);\nvar ReactCurrentOwner = __webpack_require__(78);\nvar ReactElement = __webpack_require__(79);\nvar ReactErrorUtils = __webpack_require__(121);\nvar ReactInstanceMap = __webpack_require__(91);\nvar ReactLifeCycle = __webpack_require__(105);\nvar ReactPropTypeLocations = __webpack_require__(86);\nvar ReactPropTypeLocationNames = __webpack_require__(87);\nvar ReactUpdateQueue = __webpack_require__(100);\n\nvar assign = __webpack_require__(75);\nvar invariant = __webpack_require__(64);\nvar keyMirror = __webpack_require__(67);\nvar keyOf = __webpack_require__(122);\nvar warning = __webpack_require__(82);\n\nvar MIXINS_KEY = keyOf({mixins: null});\n\n/**\n * Policies that describe methods in `ReactClassInterface`.\n */\nvar SpecPolicy = keyMirror({\n /**\n * These methods may be defined only once by the class specification or mixin.\n */\n DEFINE_ONCE: null,\n /**\n * These methods may be defined by both the class specification and mixins.\n * Subsequent definitions will be chained. These methods must return void.\n */\n DEFINE_MANY: null,\n /**\n * These methods are overriding the base class.\n */\n OVERRIDE_BASE: null,\n /**\n * These methods are similar to DEFINE_MANY, except we assume they return\n * objects. We try to merge the keys of the return values of all the mixed in\n * functions. If there is a key conflict we throw.\n */\n DEFINE_MANY_MERGED: null\n});\n\n\nvar injectedMixins = [];\n\n/**\n * Composite components are higher-level components that compose other composite\n * or native components.\n *\n * To create a new type of `ReactClass`, pass a specification of\n * your new class to `React.createClass`. The only requirement of your class\n * specification is that you implement a `render` method.\n *\n * var MyComponent = React.createClass({\n * render: function() {\n * return <div>Hello World</div>;\n * }\n * });\n *\n * The class specification supports a specific protocol of methods that have\n * special meaning (e.g. `render`). See `ReactClassInterface` for\n * more the comprehensive protocol. Any other properties and methods in the\n * class specification will available on the prototype.\n *\n * @interface ReactClassInterface\n * @internal\n */\nvar ReactClassInterface = {\n\n /**\n * An array of Mixin objects to include when defining your component.\n *\n * @type {array}\n * @optional\n */\n mixins: SpecPolicy.DEFINE_MANY,\n\n /**\n * An object containing properties and methods that should be defined on\n * the component's constructor instead of its prototype (static methods).\n *\n * @type {object}\n * @optional\n */\n statics: SpecPolicy.DEFINE_MANY,\n\n /**\n * Definition of prop types for this component.\n *\n * @type {object}\n * @optional\n */\n propTypes: SpecPolicy.DEFINE_MANY,\n\n /**\n * Definition of context types for this component.\n *\n * @type {object}\n * @optional\n */\n contextTypes: SpecPolicy.DEFINE_MANY,\n\n /**\n * Definition of context types this component sets for its children.\n *\n * @type {object}\n * @optional\n */\n childContextTypes: SpecPolicy.DEFINE_MANY,\n\n // ==== Definition methods ====\n\n /**\n * Invoked when the component is mounted. Values in the mapping will be set on\n * `this.props` if that prop is not specified (i.e. using an `in` check).\n *\n * This method is invoked before `getInitialState` and therefore cannot rely\n * on `this.state` or use `this.setState`.\n *\n * @return {object}\n * @optional\n */\n getDefaultProps: SpecPolicy.DEFINE_MANY_MERGED,\n\n /**\n * Invoked once before the component is mounted. The return value will be used\n * as the initial value of `this.state`.\n *\n * getInitialState: function() {\n * return {\n * isOn: false,\n * fooBaz: new BazFoo()\n * }\n * }\n *\n * @return {object}\n * @optional\n */\n getInitialState: SpecPolicy.DEFINE_MANY_MERGED,\n\n /**\n * @return {object}\n * @optional\n */\n getChildContext: SpecPolicy.DEFINE_MANY_MERGED,\n\n /**\n * Uses props from `this.props` and state from `this.state` to render the\n * structure of the component.\n *\n * No guarantees are made about when or how often this method is invoked, so\n * it must not have side effects.\n *\n * render: function() {\n * var name = this.props.name;\n * return <div>Hello, {name}!</div>;\n * }\n *\n * @return {ReactComponent}\n * @nosideeffects\n * @required\n */\n render: SpecPolicy.DEFINE_ONCE,\n\n\n\n // ==== Delegate methods ====\n\n /**\n * Invoked when the component is initially created and about to be mounted.\n * This may have side effects, but any external subscriptions or data created\n * by this method must be cleaned up in `componentWillUnmount`.\n *\n * @optional\n */\n componentWillMount: SpecPolicy.DEFINE_MANY,\n\n /**\n * Invoked when the component has been mounted and has a DOM representation.\n * However, there is no guarantee that the DOM node is in the document.\n *\n * Use this as an opportunity to operate on the DOM when the component has\n * been mounted (initialized and rendered) for the first time.\n *\n * @param {DOMElement} rootNode DOM element representing the component.\n * @optional\n */\n componentDidMount: SpecPolicy.DEFINE_MANY,\n\n /**\n * Invoked before the component receives new props.\n *\n * Use this as an opportunity to react to a prop transition by updating the\n * state using `this.setState`. Current props are accessed via `this.props`.\n *\n * componentWillReceiveProps: function(nextProps, nextContext) {\n * this.setState({\n * likesIncreasing: nextProps.likeCount > this.props.likeCount\n * });\n * }\n *\n * NOTE: There is no equivalent `componentWillReceiveState`. An incoming prop\n * transition may cause a state change, but the opposite is not true. If you\n * need it, you are probably looking for `componentWillUpdate`.\n *\n * @param {object} nextProps\n * @optional\n */\n componentWillReceiveProps: SpecPolicy.DEFINE_MANY,\n\n /**\n * Invoked while deciding if the component should be updated as a result of\n * receiving new props, state and/or context.\n *\n * Use this as an opportunity to `return false` when you're certain that the\n * transition to the new props/state/context will not require a component\n * update.\n *\n * shouldComponentUpdate: function(nextProps, nextState, nextContext) {\n * return !equal(nextProps, this.props) ||\n * !equal(nextState, this.state) ||\n * !equal(nextContext, this.context);\n * }\n *\n * @param {object} nextProps\n * @param {?object} nextState\n * @param {?object} nextContext\n * @return {boolean} True if the component should update.\n * @optional\n */\n shouldComponentUpdate: SpecPolicy.DEFINE_ONCE,\n\n /**\n * Invoked when the component is about to update due to a transition from\n * `this.props`, `this.state` and `this.context` to `nextProps`, `nextState`\n * and `nextContext`.\n *\n * Use this as an opportunity to perform preparation before an update occurs.\n *\n * NOTE: You **cannot** use `this.setState()` in this method.\n *\n * @param {object} nextProps\n * @param {?object} nextState\n * @param {?object} nextContext\n * @param {ReactReconcileTransaction} transaction\n * @optional\n */\n componentWillUpdate: SpecPolicy.DEFINE_MANY,\n\n /**\n * Invoked when the component's DOM representation has been updated.\n *\n * Use this as an opportunity to operate on the DOM when the component has\n * been updated.\n *\n * @param {object} prevProps\n * @param {?object} prevState\n * @param {?object} prevContext\n * @param {DOMElement} rootNode DOM element representing the component.\n * @optional\n */\n componentDidUpdate: SpecPolicy.DEFINE_MANY,\n\n /**\n * Invoked when the component is about to be removed from its parent and have\n * its DOM representation destroyed.\n *\n * Use this as an opportunity to deallocate any external resources.\n *\n * NOTE: There is no `componentDidUnmount` since your component will have been\n * destroyed by that point.\n *\n * @optional\n */\n componentWillUnmount: SpecPolicy.DEFINE_MANY,\n\n\n\n // ==== Advanced methods ====\n\n /**\n * Updates the component's currently mounted DOM representation.\n *\n * By default, this implements React's rendering and reconciliation algorithm.\n * Sophisticated clients may wish to override this.\n *\n * @param {ReactReconcileTransaction} transaction\n * @internal\n * @overridable\n */\n updateComponent: SpecPolicy.OVERRIDE_BASE\n\n};\n\n/**\n * Mapping from class specification keys to special processing functions.\n *\n * Although these are declared like instance properties in the specification\n * when defining classes using `React.createClass`, they are actually static\n * and are accessible on the constructor instead of the prototype. Despite\n * being static, they must be defined outside of the \"statics\" key under\n * which all other static methods are defined.\n */\nvar RESERVED_SPEC_KEYS = {\n displayName: function(Constructor, displayName) {\n Constructor.displayName = displayName;\n },\n mixins: function(Constructor, mixins) {\n if (mixins) {\n for (var i = 0; i < mixins.length; i++) {\n mixSpecIntoComponent(Constructor, mixins[i]);\n }\n }\n },\n childContextTypes: function(Constructor, childContextTypes) {\n if (\"production\" !== process.env.NODE_ENV) {\n validateTypeDef(\n Constructor,\n childContextTypes,\n ReactPropTypeLocations.childContext\n );\n }\n Constructor.childContextTypes = assign(\n {},\n Constructor.childContextTypes,\n childContextTypes\n );\n },\n contextTypes: function(Constructor, contextTypes) {\n if (\"production\" !== process.env.NODE_ENV) {\n validateTypeDef(\n Constructor,\n contextTypes,\n ReactPropTypeLocations.context\n );\n }\n Constructor.contextTypes = assign(\n {},\n Constructor.contextTypes,\n contextTypes\n );\n },\n /**\n * Special case getDefaultProps which should move into statics but requires\n * automatic merging.\n */\n getDefaultProps: function(Constructor, getDefaultProps) {\n if (Constructor.getDefaultProps) {\n Constructor.getDefaultProps = createMergedResultFunction(\n Constructor.getDefaultProps,\n getDefaultProps\n );\n } else {\n Constructor.getDefaultProps = getDefaultProps;\n }\n },\n propTypes: function(Constructor, propTypes) {\n if (\"production\" !== process.env.NODE_ENV) {\n validateTypeDef(\n Constructor,\n propTypes,\n ReactPropTypeLocations.prop\n );\n }\n Constructor.propTypes = assign(\n {},\n Constructor.propTypes,\n propTypes\n );\n },\n statics: function(Constructor, statics) {\n mixStaticSpecIntoComponent(Constructor, statics);\n }\n};\n\nfunction validateTypeDef(Constructor, typeDef, location) {\n for (var propName in typeDef) {\n if (typeDef.hasOwnProperty(propName)) {\n // use a warning instead of an invariant so components\n // don't show up in prod but not in __DEV__\n (\"production\" !== process.env.NODE_ENV ? warning(\n typeof typeDef[propName] === 'function',\n '%s: %s type `%s` is invalid; it must be a function, usually from ' +\n 'React.PropTypes.',\n Constructor.displayName || 'ReactClass',\n ReactPropTypeLocationNames[location],\n propName\n ) : null);\n }\n }\n}\n\nfunction validateMethodOverride(proto, name) {\n var specPolicy = ReactClassInterface.hasOwnProperty(name) ?\n ReactClassInterface[name] :\n null;\n\n // Disallow overriding of base class methods unless explicitly allowed.\n if (ReactClassMixin.hasOwnProperty(name)) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n specPolicy === SpecPolicy.OVERRIDE_BASE,\n 'ReactClassInterface: You are attempting to override ' +\n '`%s` from your class specification. Ensure that your method names ' +\n 'do not overlap with React methods.',\n name\n ) : invariant(specPolicy === SpecPolicy.OVERRIDE_BASE));\n }\n\n // Disallow defining methods more than once unless explicitly allowed.\n if (proto.hasOwnProperty(name)) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n specPolicy === SpecPolicy.DEFINE_MANY ||\n specPolicy === SpecPolicy.DEFINE_MANY_MERGED,\n 'ReactClassInterface: You are attempting to define ' +\n '`%s` on your component more than once. This conflict may be due ' +\n 'to a mixin.',\n name\n ) : invariant(specPolicy === SpecPolicy.DEFINE_MANY ||\n specPolicy === SpecPolicy.DEFINE_MANY_MERGED));\n }\n}\n\n/**\n * Mixin helper which handles policy validation and reserved\n * specification keys when building React classses.\n */\nfunction mixSpecIntoComponent(Constructor, spec) {\n if (!spec) {\n return;\n }\n\n (\"production\" !== process.env.NODE_ENV ? invariant(\n typeof spec !== 'function',\n 'ReactClass: You\\'re attempting to ' +\n 'use a component class as a mixin. Instead, just use a regular object.'\n ) : invariant(typeof spec !== 'function'));\n (\"production\" !== process.env.NODE_ENV ? invariant(\n !ReactElement.isValidElement(spec),\n 'ReactClass: You\\'re attempting to ' +\n 'use a component as a mixin. Instead, just use a regular object.'\n ) : invariant(!ReactElement.isValidElement(spec)));\n\n var proto = Constructor.prototype;\n\n // By handling mixins before any other properties, we ensure the same\n // chaining order is applied to methods with DEFINE_MANY policy, whether\n // mixins are listed before or after these methods in the spec.\n if (spec.hasOwnProperty(MIXINS_KEY)) {\n RESERVED_SPEC_KEYS.mixins(Constructor, spec.mixins);\n }\n\n for (var name in spec) {\n if (!spec.hasOwnProperty(name)) {\n continue;\n }\n\n if (name === MIXINS_KEY) {\n // We have already handled mixins in a special case above\n continue;\n }\n\n var property = spec[name];\n validateMethodOverride(proto, name);\n\n if (RESERVED_SPEC_KEYS.hasOwnProperty(name)) {\n RESERVED_SPEC_KEYS[name](Constructor, property);\n } else {\n // Setup methods on prototype:\n // The following member methods should not be automatically bound:\n // 1. Expected ReactClass methods (in the \"interface\").\n // 2. Overridden methods (that were mixed in).\n var isReactClassMethod =\n ReactClassInterface.hasOwnProperty(name);\n var isAlreadyDefined = proto.hasOwnProperty(name);\n var markedDontBind = property && property.__reactDontBind;\n var isFunction = typeof property === 'function';\n var shouldAutoBind =\n isFunction &&\n !isReactClassMethod &&\n !isAlreadyDefined &&\n !markedDontBind;\n\n if (shouldAutoBind) {\n if (!proto.__reactAutoBindMap) {\n proto.__reactAutoBindMap = {};\n }\n proto.__reactAutoBindMap[name] = property;\n proto[name] = property;\n } else {\n if (isAlreadyDefined) {\n var specPolicy = ReactClassInterface[name];\n\n // These cases should already be caught by validateMethodOverride\n (\"production\" !== process.env.NODE_ENV ? invariant(\n isReactClassMethod && (\n (specPolicy === SpecPolicy.DEFINE_MANY_MERGED || specPolicy === SpecPolicy.DEFINE_MANY)\n ),\n 'ReactClass: Unexpected spec policy %s for key %s ' +\n 'when mixing in component specs.',\n specPolicy,\n name\n ) : invariant(isReactClassMethod && (\n (specPolicy === SpecPolicy.DEFINE_MANY_MERGED || specPolicy === SpecPolicy.DEFINE_MANY)\n )));\n\n // For methods which are defined more than once, call the existing\n // methods before calling the new property, merging if appropriate.\n if (specPolicy === SpecPolicy.DEFINE_MANY_MERGED) {\n proto[name] = createMergedResultFunction(proto[name], property);\n } else if (specPolicy === SpecPolicy.DEFINE_MANY) {\n proto[name] = createChainedFunction(proto[name], property);\n }\n } else {\n proto[name] = property;\n if (\"production\" !== process.env.NODE_ENV) {\n // Add verbose displayName to the function, which helps when looking\n // at profiling tools.\n if (typeof property === 'function' && spec.displayName) {\n proto[name].displayName = spec.displayName + '_' + name;\n }\n }\n }\n }\n }\n }\n}\n\nfunction mixStaticSpecIntoComponent(Constructor, statics) {\n if (!statics) {\n return;\n }\n for (var name in statics) {\n var property = statics[name];\n if (!statics.hasOwnProperty(name)) {\n continue;\n }\n\n var isReserved = name in RESERVED_SPEC_KEYS;\n (\"production\" !== process.env.NODE_ENV ? invariant(\n !isReserved,\n 'ReactClass: You are attempting to define a reserved ' +\n 'property, `%s`, that shouldn\\'t be on the \"statics\" key. Define it ' +\n 'as an instance property instead; it will still be accessible on the ' +\n 'constructor.',\n name\n ) : invariant(!isReserved));\n\n var isInherited = name in Constructor;\n (\"production\" !== process.env.NODE_ENV ? invariant(\n !isInherited,\n 'ReactClass: You are attempting to define ' +\n '`%s` on your component more than once. This conflict may be ' +\n 'due to a mixin.',\n name\n ) : invariant(!isInherited));\n Constructor[name] = property;\n }\n}\n\n/**\n * Merge two objects, but throw if both contain the same key.\n *\n * @param {object} one The first object, which is mutated.\n * @param {object} two The second object\n * @return {object} one after it has been mutated to contain everything in two.\n */\nfunction mergeIntoWithNoDuplicateKeys(one, two) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n one && two && typeof one === 'object' && typeof two === 'object',\n 'mergeIntoWithNoDuplicateKeys(): Cannot merge non-objects.'\n ) : invariant(one && two && typeof one === 'object' && typeof two === 'object'));\n\n for (var key in two) {\n if (two.hasOwnProperty(key)) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n one[key] === undefined,\n 'mergeIntoWithNoDuplicateKeys(): ' +\n 'Tried to merge two objects with the same key: `%s`. This conflict ' +\n 'may be due to a mixin; in particular, this may be caused by two ' +\n 'getInitialState() or getDefaultProps() methods returning objects ' +\n 'with clashing keys.',\n key\n ) : invariant(one[key] === undefined));\n one[key] = two[key];\n }\n }\n return one;\n}\n\n/**\n * Creates a function that invokes two functions and merges their return values.\n *\n * @param {function} one Function to invoke first.\n * @param {function} two Function to invoke second.\n * @return {function} Function that invokes the two argument functions.\n * @private\n */\nfunction createMergedResultFunction(one, two) {\n return function mergedResult() {\n var a = one.apply(this, arguments);\n var b = two.apply(this, arguments);\n if (a == null) {\n return b;\n } else if (b == null) {\n return a;\n }\n var c = {};\n mergeIntoWithNoDuplicateKeys(c, a);\n mergeIntoWithNoDuplicateKeys(c, b);\n return c;\n };\n}\n\n/**\n * Creates a function that invokes two functions and ignores their return vales.\n *\n * @param {function} one Function to invoke first.\n * @param {function} two Function to invoke second.\n * @return {function} Function that invokes the two argument functions.\n * @private\n */\nfunction createChainedFunction(one, two) {\n return function chainedFunction() {\n one.apply(this, arguments);\n two.apply(this, arguments);\n };\n}\n\n/**\n * Binds a method to the component.\n *\n * @param {object} component Component whose method is going to be bound.\n * @param {function} method Method to be bound.\n * @return {function} The bound method.\n */\nfunction bindAutoBindMethod(component, method) {\n var boundMethod = method.bind(component);\n if (\"production\" !== process.env.NODE_ENV) {\n boundMethod.__reactBoundContext = component;\n boundMethod.__reactBoundMethod = method;\n boundMethod.__reactBoundArguments = null;\n var componentName = component.constructor.displayName;\n var _bind = boundMethod.bind;\n /* eslint-disable block-scoped-var, no-undef */\n boundMethod.bind = function(newThis ) {for (var args=[],$__0=1,$__1=arguments.length;$__0<$__1;$__0++) args.push(arguments[$__0]);\n // User is trying to bind() an autobound method; we effectively will\n // ignore the value of \"this\" that the user is trying to use, so\n // let's warn.\n if (newThis !== component && newThis !== null) {\n (\"production\" !== process.env.NODE_ENV ? warning(\n false,\n 'bind(): React component methods may only be bound to the ' +\n 'component instance. See %s',\n componentName\n ) : null);\n } else if (!args.length) {\n (\"production\" !== process.env.NODE_ENV ? warning(\n false,\n 'bind(): You are binding a component method to the component. ' +\n 'React does this for you automatically in a high-performance ' +\n 'way, so you can safely remove this call. See %s',\n componentName\n ) : null);\n return boundMethod;\n }\n var reboundMethod = _bind.apply(boundMethod, arguments);\n reboundMethod.__reactBoundContext = component;\n reboundMethod.__reactBoundMethod = method;\n reboundMethod.__reactBoundArguments = args;\n return reboundMethod;\n /* eslint-enable */\n };\n }\n return boundMethod;\n}\n\n/**\n * Binds all auto-bound methods in a component.\n *\n * @param {object} component Component whose method is going to be bound.\n */\nfunction bindAutoBindMethods(component) {\n for (var autoBindKey in component.__reactAutoBindMap) {\n if (component.__reactAutoBindMap.hasOwnProperty(autoBindKey)) {\n var method = component.__reactAutoBindMap[autoBindKey];\n component[autoBindKey] = bindAutoBindMethod(\n component,\n ReactErrorUtils.guard(\n method,\n component.constructor.displayName + '.' + autoBindKey\n )\n );\n }\n }\n}\n\nvar typeDeprecationDescriptor = {\n enumerable: false,\n get: function() {\n var displayName = this.displayName || this.name || 'Component';\n (\"production\" !== process.env.NODE_ENV ? warning(\n false,\n '%s.type is deprecated. Use %s directly to access the class.',\n displayName,\n displayName\n ) : null);\n Object.defineProperty(this, 'type', {\n value: this\n });\n return this;\n }\n};\n\n/**\n * Add more to the ReactClass base class. These are all legacy features and\n * therefore not already part of the modern ReactComponent.\n */\nvar ReactClassMixin = {\n\n /**\n * TODO: This will be deprecated because state should always keep a consistent\n * type signature and the only use case for this, is to avoid that.\n */\n replaceState: function(newState, callback) {\n ReactUpdateQueue.enqueueReplaceState(this, newState);\n if (callback) {\n ReactUpdateQueue.enqueueCallback(this, callback);\n }\n },\n\n /**\n * Checks whether or not this composite component is mounted.\n * @return {boolean} True if mounted, false otherwise.\n * @protected\n * @final\n */\n isMounted: function() {\n if (\"production\" !== process.env.NODE_ENV) {\n var owner = ReactCurrentOwner.current;\n if (owner !== null) {\n (\"production\" !== process.env.NODE_ENV ? warning(\n owner._warnedAboutRefsInRender,\n '%s is accessing isMounted inside its render() function. ' +\n 'render() should be a pure function of props and state. It should ' +\n 'never access something that requires stale data from the previous ' +\n 'render, such as refs. Move this logic to componentDidMount and ' +\n 'componentDidUpdate instead.',\n owner.getName() || 'A component'\n ) : null);\n owner._warnedAboutRefsInRender = true;\n }\n }\n var internalInstance = ReactInstanceMap.get(this);\n return (\n internalInstance &&\n internalInstance !== ReactLifeCycle.currentlyMountingInstance\n );\n },\n\n /**\n * Sets a subset of the props.\n *\n * @param {object} partialProps Subset of the next props.\n * @param {?function} callback Called after props are updated.\n * @final\n * @public\n * @deprecated\n */\n setProps: function(partialProps, callback) {\n ReactUpdateQueue.enqueueSetProps(this, partialProps);\n if (callback) {\n ReactUpdateQueue.enqueueCallback(this, callback);\n }\n },\n\n /**\n * Replace all the props.\n *\n * @param {object} newProps Subset of the next props.\n * @param {?function} callback Called after props are updated.\n * @final\n * @public\n * @deprecated\n */\n replaceProps: function(newProps, callback) {\n ReactUpdateQueue.enqueueReplaceProps(this, newProps);\n if (callback) {\n ReactUpdateQueue.enqueueCallback(this, callback);\n }\n }\n};\n\nvar ReactClassComponent = function() {};\nassign(\n ReactClassComponent.prototype,\n ReactComponent.prototype,\n ReactClassMixin\n);\n\n/**\n * Module for creating composite components.\n *\n * @class ReactClass\n */\nvar ReactClass = {\n\n /**\n * Creates a composite component class given a class specification.\n *\n * @param {object} spec Class specification (which must define `render`).\n * @return {function} Component constructor function.\n * @public\n */\n createClass: function(spec) {\n var Constructor = function(props, context) {\n // This constructor is overridden by mocks. The argument is used\n // by mocks to assert on what gets mounted.\n\n if (\"production\" !== process.env.NODE_ENV) {\n (\"production\" !== process.env.NODE_ENV ? warning(\n this instanceof Constructor,\n 'Something is calling a React component directly. Use a factory or ' +\n 'JSX instead. See: https://fb.me/react-legacyfactory'\n ) : null);\n }\n\n // Wire up auto-binding\n if (this.__reactAutoBindMap) {\n bindAutoBindMethods(this);\n }\n\n this.props = props;\n this.context = context;\n this.state = null;\n\n // ReactClasses doesn't have constructors. Instead, they use the\n // getInitialState and componentWillMount methods for initialization.\n\n var initialState = this.getInitialState ? this.getInitialState() : null;\n if (\"production\" !== process.env.NODE_ENV) {\n // We allow auto-mocks to proceed as if they're returning null.\n if (typeof initialState === 'undefined' &&\n this.getInitialState._isMockFunction) {\n // This is probably bad practice. Consider warning here and\n // deprecating this convenience.\n initialState = null;\n }\n }\n (\"production\" !== process.env.NODE_ENV ? invariant(\n typeof initialState === 'object' && !Array.isArray(initialState),\n '%s.getInitialState(): must return an object or null',\n Constructor.displayName || 'ReactCompositeComponent'\n ) : invariant(typeof initialState === 'object' && !Array.isArray(initialState)));\n\n this.state = initialState;\n };\n Constructor.prototype = new ReactClassComponent();\n Constructor.prototype.constructor = Constructor;\n\n injectedMixins.forEach(\n mixSpecIntoComponent.bind(null, Constructor)\n );\n\n mixSpecIntoComponent(Constructor, spec);\n\n // Initialize the defaultProps property after all mixins have been merged\n if (Constructor.getDefaultProps) {\n Constructor.defaultProps = Constructor.getDefaultProps();\n }\n\n if (\"production\" !== process.env.NODE_ENV) {\n // This is a tag to indicate that the use of these method names is ok,\n // since it's used with createClass. If it's not, then it's likely a\n // mistake so we'll warn you to use the static property, property\n // initializer or constructor respectively.\n if (Constructor.getDefaultProps) {\n Constructor.getDefaultProps.isReactClassApproved = {};\n }\n if (Constructor.prototype.getInitialState) {\n Constructor.prototype.getInitialState.isReactClassApproved = {};\n }\n }\n\n (\"production\" !== process.env.NODE_ENV ? invariant(\n Constructor.prototype.render,\n 'createClass(...): Class specification must implement a `render` method.'\n ) : invariant(Constructor.prototype.render));\n\n if (\"production\" !== process.env.NODE_ENV) {\n (\"production\" !== process.env.NODE_ENV ? warning(\n !Constructor.prototype.componentShouldUpdate,\n '%s has a method called ' +\n 'componentShouldUpdate(). Did you mean shouldComponentUpdate()? ' +\n 'The name is phrased as a question because the function is ' +\n 'expected to return a value.',\n spec.displayName || 'A component'\n ) : null);\n }\n\n // Reduce time spent doing lookups by setting these on the prototype.\n for (var methodName in ReactClassInterface) {\n if (!Constructor.prototype[methodName]) {\n Constructor.prototype[methodName] = null;\n }\n }\n\n // Legacy hook\n Constructor.type = Constructor;\n if (\"production\" !== process.env.NODE_ENV) {\n try {\n Object.defineProperty(Constructor, 'type', typeDeprecationDescriptor);\n } catch (x) {\n // IE will fail on defineProperty (es5-shim/sham too)\n }\n }\n\n return Constructor;\n },\n\n injection: {\n injectMixin: function(mixin) {\n injectedMixins.push(mixin);\n }\n }\n\n};\n\nmodule.exports = ReactClass;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactClass.js\n ** module id = 120\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ReactClass.js?");
|
||
|
||
/***/ },
|
||
/* 121 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("/**\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 ReactErrorUtils\n * @typechecks\n */\n\n\"use strict\";\n\nvar ReactErrorUtils = {\n /**\n * Creates a guarded version of a function. This is supposed to make debugging\n * of event handlers easier. To aid debugging with the browser's debugger,\n * this currently simply returns the original function.\n *\n * @param {function} func Function to be executed\n * @param {string} name The name of the guard\n * @return {function}\n */\n guard: function(func, name) {\n return func;\n }\n};\n\nmodule.exports = ReactErrorUtils;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactErrorUtils.js\n ** module id = 121\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ReactErrorUtils.js?");
|
||
|
||
/***/ },
|
||
/* 122 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("/**\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 keyOf\n */\n\n/**\n * Allows extraction of a minified key. Let's the build system minify keys\n * without loosing the ability to dynamically use key strings as values\n * themselves. Pass in an object with a single key/val pair and it will return\n * you the string key of that single record. Suppose you want to grab the\n * value for a key 'className' inside of an object. Key/val minification may\n * have aliased that key to be 'xa12'. keyOf({className: null}) will return\n * 'xa12' in that case. Resolve keys you want to use once at startup time, then\n * reuse those resolutions.\n */\nvar keyOf = function(oneKeyObj) {\n var key;\n for (key in oneKeyObj) {\n if (!oneKeyObj.hasOwnProperty(key)) {\n continue;\n }\n return key;\n }\n return null;\n};\n\n\nmodule.exports = keyOf;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/keyOf.js\n ** module id = 122\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/keyOf.js?");
|
||
|
||
/***/ },
|
||
/* 123 */
|
||
/***/ 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 ReactDOM\n * @typechecks static-only\n */\n\n'use strict';\n\nvar ReactElement = __webpack_require__(79);\nvar ReactElementValidator = __webpack_require__(84);\n\nvar mapObject = __webpack_require__(124);\n\n/**\n * Create a factory that creates HTML tag elements.\n *\n * @param {string} tag Tag name (e.g. `div`).\n * @private\n */\nfunction createDOMFactory(tag) {\n if (\"production\" !== process.env.NODE_ENV) {\n return ReactElementValidator.createFactory(tag);\n }\n return ReactElement.createFactory(tag);\n}\n\n/**\n * Creates a mapping from supported HTML tags to `ReactDOMComponent` classes.\n * This is also accessible via `React.DOM`.\n *\n * @public\n */\nvar ReactDOM = mapObject({\n a: 'a',\n abbr: 'abbr',\n address: 'address',\n area: 'area',\n article: 'article',\n aside: 'aside',\n audio: 'audio',\n b: 'b',\n base: 'base',\n bdi: 'bdi',\n bdo: 'bdo',\n big: 'big',\n blockquote: 'blockquote',\n body: 'body',\n br: 'br',\n button: 'button',\n canvas: 'canvas',\n caption: 'caption',\n cite: 'cite',\n code: 'code',\n col: 'col',\n colgroup: 'colgroup',\n data: 'data',\n datalist: 'datalist',\n dd: 'dd',\n del: 'del',\n details: 'details',\n dfn: 'dfn',\n dialog: 'dialog',\n div: 'div',\n dl: 'dl',\n dt: 'dt',\n em: 'em',\n embed: 'embed',\n fieldset: 'fieldset',\n figcaption: 'figcaption',\n figure: 'figure',\n footer: 'footer',\n form: 'form',\n h1: 'h1',\n h2: 'h2',\n h3: 'h3',\n h4: 'h4',\n h5: 'h5',\n h6: 'h6',\n head: 'head',\n header: 'header',\n hr: 'hr',\n html: 'html',\n i: 'i',\n iframe: 'iframe',\n img: 'img',\n input: 'input',\n ins: 'ins',\n kbd: 'kbd',\n keygen: 'keygen',\n label: 'label',\n legend: 'legend',\n li: 'li',\n link: 'link',\n main: 'main',\n map: 'map',\n mark: 'mark',\n menu: 'menu',\n menuitem: 'menuitem',\n meta: 'meta',\n meter: 'meter',\n nav: 'nav',\n noscript: 'noscript',\n object: 'object',\n ol: 'ol',\n optgroup: 'optgroup',\n option: 'option',\n output: 'output',\n p: 'p',\n param: 'param',\n picture: 'picture',\n pre: 'pre',\n progress: 'progress',\n q: 'q',\n rp: 'rp',\n rt: 'rt',\n ruby: 'ruby',\n s: 's',\n samp: 'samp',\n script: 'script',\n section: 'section',\n select: 'select',\n small: 'small',\n source: 'source',\n span: 'span',\n strong: 'strong',\n style: 'style',\n sub: 'sub',\n summary: 'summary',\n sup: 'sup',\n table: 'table',\n tbody: 'tbody',\n td: 'td',\n textarea: 'textarea',\n tfoot: 'tfoot',\n th: 'th',\n thead: 'thead',\n time: 'time',\n title: 'title',\n tr: 'tr',\n track: 'track',\n u: 'u',\n ul: 'ul',\n 'var': 'var',\n video: 'video',\n wbr: 'wbr',\n\n // SVG\n circle: 'circle',\n clipPath: 'clipPath',\n defs: 'defs',\n ellipse: 'ellipse',\n g: 'g',\n line: 'line',\n linearGradient: 'linearGradient',\n mask: 'mask',\n path: 'path',\n pattern: 'pattern',\n polygon: 'polygon',\n polyline: 'polyline',\n radialGradient: 'radialGradient',\n rect: 'rect',\n stop: 'stop',\n svg: 'svg',\n text: 'text',\n tspan: 'tspan'\n\n}, createDOMFactory);\n\nmodule.exports = ReactDOM;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactDOM.js\n ** module id = 123\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ReactDOM.js?");
|
||
|
||
/***/ },
|
||
/* 124 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("/**\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 mapObject\n */\n\n'use strict';\n\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n\n/**\n * Executes the provided `callback` once for each enumerable own property in the\n * object and constructs a new object from the results. The `callback` is\n * invoked with three arguments:\n *\n * - the property value\n * - the property name\n * - the object being traversed\n *\n * Properties that are added after the call to `mapObject` will not be visited\n * by `callback`. If the values of existing properties are changed, the value\n * passed to `callback` will be the value at the time `mapObject` visits them.\n * Properties that are deleted before being visited are not visited.\n *\n * @grep function objectMap()\n * @grep function objMap()\n *\n * @param {?object} object\n * @param {function} callback\n * @param {*} context\n * @return {?object}\n */\nfunction mapObject(object, callback, context) {\n if (!object) {\n return null;\n }\n var result = {};\n for (var name in object) {\n if (hasOwnProperty.call(object, name)) {\n result[name] = callback.call(context, object[name], name, object);\n }\n }\n return result;\n}\n\nmodule.exports = mapObject;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/mapObject.js\n ** module id = 124\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/mapObject.js?");
|
||
|
||
/***/ },
|
||
/* 125 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\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 ReactDOMTextComponent\n * @typechecks static-only\n */\n\n'use strict';\n\nvar DOMPropertyOperations = __webpack_require__(126);\nvar ReactComponentBrowserEnvironment =\n __webpack_require__(129);\nvar ReactDOMComponent = __webpack_require__(147);\n\nvar assign = __webpack_require__(75);\nvar escapeTextContentForBrowser = __webpack_require__(128);\n\n/**\n * Text nodes violate a couple assumptions that React makes about components:\n *\n * - When mounting text into the DOM, adjacent text nodes are merged.\n * - Text nodes cannot be assigned a React root ID.\n *\n * This component is used to wrap strings in elements so that they can undergo\n * the same reconciliation that is applied to elements.\n *\n * TODO: Investigate representing React components in the DOM with text nodes.\n *\n * @class ReactDOMTextComponent\n * @extends ReactComponent\n * @internal\n */\nvar ReactDOMTextComponent = function(props) {\n // This constructor and its argument is currently used by mocks.\n};\n\nassign(ReactDOMTextComponent.prototype, {\n\n /**\n * @param {ReactText} text\n * @internal\n */\n construct: function(text) {\n // TODO: This is really a ReactText (ReactNode), not a ReactElement\n this._currentElement = text;\n this._stringText = '' + text;\n\n // Properties\n this._rootNodeID = null;\n this._mountIndex = 0;\n },\n\n /**\n * Creates the markup for this text node. This node is not intended to have\n * any features besides containing text content.\n *\n * @param {string} rootID DOM ID of the root node.\n * @param {ReactReconcileTransaction|ReactServerRenderingTransaction} transaction\n * @return {string} Markup for this text node.\n * @internal\n */\n mountComponent: function(rootID, transaction, context) {\n this._rootNodeID = rootID;\n var escapedText = escapeTextContentForBrowser(this._stringText);\n\n if (transaction.renderToStaticMarkup) {\n // Normally we'd wrap this in a `span` for the reasons stated above, but\n // since this is a situation where React won't take over (static pages),\n // we can simply return the text as it is.\n return escapedText;\n }\n\n return (\n '<span ' + DOMPropertyOperations.createMarkupForID(rootID) + '>' +\n escapedText +\n '</span>'\n );\n },\n\n /**\n * Updates this component by updating the text content.\n *\n * @param {ReactText} nextText The next text content\n * @param {ReactReconcileTransaction} transaction\n * @internal\n */\n receiveComponent: function(nextText, transaction) {\n if (nextText !== this._currentElement) {\n this._currentElement = nextText;\n var nextStringText = '' + nextText;\n if (nextStringText !== this._stringText) {\n // TODO: Save this as pending props and use performUpdateIfNecessary\n // and/or updateComponent to do the actual update for consistency with\n // other component types?\n this._stringText = nextStringText;\n ReactDOMComponent.BackendIDOperations.updateTextContentByID(\n this._rootNodeID,\n nextStringText\n );\n }\n }\n },\n\n unmountComponent: function() {\n ReactComponentBrowserEnvironment.unmountIDFromEnvironment(this._rootNodeID);\n }\n\n});\n\nmodule.exports = ReactDOMTextComponent;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactDOMTextComponent.js\n ** module id = 125\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ReactDOMTextComponent.js?");
|
||
|
||
/***/ },
|
||
/* 126 */
|
||
/***/ 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 DOMPropertyOperations\n * @typechecks static-only\n */\n\n'use strict';\n\nvar DOMProperty = __webpack_require__(63);\n\nvar quoteAttributeValueForBrowser = __webpack_require__(127);\nvar warning = __webpack_require__(82);\n\nfunction shouldIgnoreValue(name, value) {\n return value == null ||\n (DOMProperty.hasBooleanValue[name] && !value) ||\n (DOMProperty.hasNumericValue[name] && isNaN(value)) ||\n (DOMProperty.hasPositiveNumericValue[name] && (value < 1)) ||\n (DOMProperty.hasOverloadedBooleanValue[name] && value === false);\n}\n\nif (\"production\" !== process.env.NODE_ENV) {\n var reactProps = {\n children: true,\n dangerouslySetInnerHTML: true,\n key: true,\n ref: true\n };\n var warnedProperties = {};\n\n var warnUnknownProperty = function(name) {\n if (reactProps.hasOwnProperty(name) && reactProps[name] ||\n warnedProperties.hasOwnProperty(name) && warnedProperties[name]) {\n return;\n }\n\n warnedProperties[name] = true;\n var lowerCasedName = name.toLowerCase();\n\n // data-* attributes should be lowercase; suggest the lowercase version\n var standardName = (\n DOMProperty.isCustomAttribute(lowerCasedName) ?\n lowerCasedName :\n DOMProperty.getPossibleStandardName.hasOwnProperty(lowerCasedName) ?\n DOMProperty.getPossibleStandardName[lowerCasedName] :\n null\n );\n\n // For now, only warn when we have a suggested correction. This prevents\n // logging too much when using transferPropsTo.\n (\"production\" !== process.env.NODE_ENV ? warning(\n standardName == null,\n 'Unknown DOM property %s. Did you mean %s?',\n name,\n standardName\n ) : null);\n\n };\n}\n\n/**\n * Operations for dealing with DOM properties.\n */\nvar DOMPropertyOperations = {\n\n /**\n * Creates markup for the ID property.\n *\n * @param {string} id Unescaped ID.\n * @return {string} Markup string.\n */\n createMarkupForID: function(id) {\n return DOMProperty.ID_ATTRIBUTE_NAME + '=' +\n quoteAttributeValueForBrowser(id);\n },\n\n /**\n * Creates markup for a property.\n *\n * @param {string} name\n * @param {*} value\n * @return {?string} Markup string, or null if the property was invalid.\n */\n createMarkupForProperty: function(name, value) {\n if (DOMProperty.isStandardName.hasOwnProperty(name) &&\n DOMProperty.isStandardName[name]) {\n if (shouldIgnoreValue(name, value)) {\n return '';\n }\n var attributeName = DOMProperty.getAttributeName[name];\n if (DOMProperty.hasBooleanValue[name] ||\n (DOMProperty.hasOverloadedBooleanValue[name] && value === true)) {\n return attributeName;\n }\n return attributeName + '=' + quoteAttributeValueForBrowser(value);\n } else if (DOMProperty.isCustomAttribute(name)) {\n if (value == null) {\n return '';\n }\n return name + '=' + quoteAttributeValueForBrowser(value);\n } else if (\"production\" !== process.env.NODE_ENV) {\n warnUnknownProperty(name);\n }\n return null;\n },\n\n /**\n * Sets the value for a property on a node.\n *\n * @param {DOMElement} node\n * @param {string} name\n * @param {*} value\n */\n setValueForProperty: function(node, name, value) {\n if (DOMProperty.isStandardName.hasOwnProperty(name) &&\n DOMProperty.isStandardName[name]) {\n var mutationMethod = DOMProperty.getMutationMethod[name];\n if (mutationMethod) {\n mutationMethod(node, value);\n } else if (shouldIgnoreValue(name, value)) {\n this.deleteValueForProperty(node, name);\n } else if (DOMProperty.mustUseAttribute[name]) {\n // `setAttribute` with objects becomes only `[object]` in IE8/9,\n // ('' + value) makes it output the correct toString()-value.\n node.setAttribute(DOMProperty.getAttributeName[name], '' + value);\n } else {\n var propName = DOMProperty.getPropertyName[name];\n // Must explicitly cast values for HAS_SIDE_EFFECTS-properties to the\n // property type before comparing; only `value` does and is string.\n if (!DOMProperty.hasSideEffects[name] ||\n ('' + node[propName]) !== ('' + value)) {\n // Contrary to `setAttribute`, object properties are properly\n // `toString`ed by IE8/9.\n node[propName] = value;\n }\n }\n } else if (DOMProperty.isCustomAttribute(name)) {\n if (value == null) {\n node.removeAttribute(name);\n } else {\n node.setAttribute(name, '' + value);\n }\n } else if (\"production\" !== process.env.NODE_ENV) {\n warnUnknownProperty(name);\n }\n },\n\n /**\n * Deletes the value for a property on a node.\n *\n * @param {DOMElement} node\n * @param {string} name\n */\n deleteValueForProperty: function(node, name) {\n if (DOMProperty.isStandardName.hasOwnProperty(name) &&\n DOMProperty.isStandardName[name]) {\n var mutationMethod = DOMProperty.getMutationMethod[name];\n if (mutationMethod) {\n mutationMethod(node, undefined);\n } else if (DOMProperty.mustUseAttribute[name]) {\n node.removeAttribute(DOMProperty.getAttributeName[name]);\n } else {\n var propName = DOMProperty.getPropertyName[name];\n var defaultValue = DOMProperty.getDefaultValueForProperty(\n node.nodeName,\n propName\n );\n if (!DOMProperty.hasSideEffects[name] ||\n ('' + node[propName]) !== defaultValue) {\n node[propName] = defaultValue;\n }\n }\n } else if (DOMProperty.isCustomAttribute(name)) {\n node.removeAttribute(name);\n } else if (\"production\" !== process.env.NODE_ENV) {\n warnUnknownProperty(name);\n }\n }\n\n};\n\nmodule.exports = DOMPropertyOperations;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/DOMPropertyOperations.js\n ** module id = 126\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/DOMPropertyOperations.js?");
|
||
|
||
/***/ },
|
||
/* 127 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\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 quoteAttributeValueForBrowser\n */\n\n'use strict';\n\nvar escapeTextContentForBrowser = __webpack_require__(128);\n\n/**\n * Escapes attribute value to prevent scripting attacks.\n *\n * @param {*} value Value to escape.\n * @return {string} An escaped string.\n */\nfunction quoteAttributeValueForBrowser(value) {\n return '\"' + escapeTextContentForBrowser(value) + '\"';\n}\n\nmodule.exports = quoteAttributeValueForBrowser;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/quoteAttributeValueForBrowser.js\n ** module id = 127\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/quoteAttributeValueForBrowser.js?");
|
||
|
||
/***/ },
|
||
/* 128 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("/**\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 escapeTextContentForBrowser\n */\n\n'use strict';\n\nvar ESCAPE_LOOKUP = {\n '&': '&',\n '>': '>',\n '<': '<',\n '\"': '"',\n '\\'': '''\n};\n\nvar ESCAPE_REGEX = /[&><\"']/g;\n\nfunction escaper(match) {\n return ESCAPE_LOOKUP[match];\n}\n\n/**\n * Escapes text to prevent scripting attacks.\n *\n * @param {*} text Text value to escape.\n * @return {string} An escaped string.\n */\nfunction escapeTextContentForBrowser(text) {\n return ('' + text).replace(ESCAPE_REGEX, escaper);\n}\n\nmodule.exports = escapeTextContentForBrowser;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/escapeTextContentForBrowser.js\n ** module id = 128\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/escapeTextContentForBrowser.js?");
|
||
|
||
/***/ },
|
||
/* 129 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\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 ReactComponentBrowserEnvironment\n */\n\n/*jslint evil: true */\n\n'use strict';\n\nvar ReactDOMIDOperations = __webpack_require__(130);\nvar ReactMount = __webpack_require__(61);\n\n/**\n * Abstracts away all functionality of the reconciler that requires knowledge of\n * the browser context. TODO: These callers should be refactored to avoid the\n * need for this injection.\n */\nvar ReactComponentBrowserEnvironment = {\n\n processChildrenUpdates:\n ReactDOMIDOperations.dangerouslyProcessChildrenUpdates,\n\n replaceNodeWithMarkupByID:\n ReactDOMIDOperations.dangerouslyReplaceNodeWithMarkupByID,\n\n /**\n * If a particular environment requires that some resources be cleaned up,\n * specify this in the injected Mixin. In the DOM, we would likely want to\n * purge any cached node ID lookups.\n *\n * @private\n */\n unmountIDFromEnvironment: function(rootNodeID) {\n ReactMount.purgeID(rootNodeID);\n }\n\n};\n\nmodule.exports = ReactComponentBrowserEnvironment;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactComponentBrowserEnvironment.js\n ** module id = 129\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ReactComponentBrowserEnvironment.js?");
|
||
|
||
/***/ },
|
||
/* 130 */
|
||
/***/ 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 ReactDOMIDOperations\n * @typechecks static-only\n */\n\n/*jslint evil: true */\n\n'use strict';\n\nvar CSSPropertyOperations = __webpack_require__(131);\nvar DOMChildrenOperations = __webpack_require__(139);\nvar DOMPropertyOperations = __webpack_require__(126);\nvar ReactMount = __webpack_require__(61);\nvar ReactPerf = __webpack_require__(96);\n\nvar invariant = __webpack_require__(64);\nvar setInnerHTML = __webpack_require__(114);\n\n/**\n * Errors for properties that should not be updated with `updatePropertyById()`.\n *\n * @type {object}\n * @private\n */\nvar INVALID_PROPERTY_ERRORS = {\n dangerouslySetInnerHTML:\n '`dangerouslySetInnerHTML` must be set using `updateInnerHTMLByID()`.',\n style: '`style` must be set using `updateStylesByID()`.'\n};\n\n/**\n * Operations used to process updates to DOM nodes. This is made injectable via\n * `ReactDOMComponent.BackendIDOperations`.\n */\nvar ReactDOMIDOperations = {\n\n /**\n * Updates a DOM node with new property values. This should only be used to\n * update DOM properties in `DOMProperty`.\n *\n * @param {string} id ID of the node to update.\n * @param {string} name A valid property name, see `DOMProperty`.\n * @param {*} value New value of the property.\n * @internal\n */\n updatePropertyByID: function(id, name, value) {\n var node = ReactMount.getNode(id);\n (\"production\" !== process.env.NODE_ENV ? invariant(\n !INVALID_PROPERTY_ERRORS.hasOwnProperty(name),\n 'updatePropertyByID(...): %s',\n INVALID_PROPERTY_ERRORS[name]\n ) : invariant(!INVALID_PROPERTY_ERRORS.hasOwnProperty(name)));\n\n // If we're updating to null or undefined, we should remove the property\n // from the DOM node instead of inadvertantly setting to a string. This\n // brings us in line with the same behavior we have on initial render.\n if (value != null) {\n DOMPropertyOperations.setValueForProperty(node, name, value);\n } else {\n DOMPropertyOperations.deleteValueForProperty(node, name);\n }\n },\n\n /**\n * Updates a DOM node to remove a property. This should only be used to remove\n * DOM properties in `DOMProperty`.\n *\n * @param {string} id ID of the node to update.\n * @param {string} name A property name to remove, see `DOMProperty`.\n * @internal\n */\n deletePropertyByID: function(id, name, value) {\n var node = ReactMount.getNode(id);\n (\"production\" !== process.env.NODE_ENV ? invariant(\n !INVALID_PROPERTY_ERRORS.hasOwnProperty(name),\n 'updatePropertyByID(...): %s',\n INVALID_PROPERTY_ERRORS[name]\n ) : invariant(!INVALID_PROPERTY_ERRORS.hasOwnProperty(name)));\n DOMPropertyOperations.deleteValueForProperty(node, name, value);\n },\n\n /**\n * Updates a DOM node with new style values. If a value is specified as '',\n * the corresponding style property will be unset.\n *\n * @param {string} id ID of the node to update.\n * @param {object} styles Mapping from styles to values.\n * @internal\n */\n updateStylesByID: function(id, styles) {\n var node = ReactMount.getNode(id);\n CSSPropertyOperations.setValueForStyles(node, styles);\n },\n\n /**\n * Updates a DOM node's innerHTML.\n *\n * @param {string} id ID of the node to update.\n * @param {string} html An HTML string.\n * @internal\n */\n updateInnerHTMLByID: function(id, html) {\n var node = ReactMount.getNode(id);\n setInnerHTML(node, html);\n },\n\n /**\n * Updates a DOM node's text content set by `props.content`.\n *\n * @param {string} id ID of the node to update.\n * @param {string} content Text content.\n * @internal\n */\n updateTextContentByID: function(id, content) {\n var node = ReactMount.getNode(id);\n DOMChildrenOperations.updateTextContent(node, content);\n },\n\n /**\n * Replaces a DOM node that exists in the document with markup.\n *\n * @param {string} id ID of child to be replaced.\n * @param {string} markup Dangerous markup to inject in place of child.\n * @internal\n * @see {Danger.dangerouslyReplaceNodeWithMarkup}\n */\n dangerouslyReplaceNodeWithMarkupByID: function(id, markup) {\n var node = ReactMount.getNode(id);\n DOMChildrenOperations.dangerouslyReplaceNodeWithMarkup(node, markup);\n },\n\n /**\n * Updates a component's children by processing a series of updates.\n *\n * @param {array<object>} updates List of update configurations.\n * @param {array<string>} markup List of markup strings.\n * @internal\n */\n dangerouslyProcessChildrenUpdates: function(updates, markup) {\n for (var i = 0; i < updates.length; i++) {\n updates[i].parentNode = ReactMount.getNode(updates[i].parentID);\n }\n DOMChildrenOperations.processUpdates(updates, markup);\n }\n};\n\nReactPerf.measureMethods(ReactDOMIDOperations, 'ReactDOMIDOperations', {\n updatePropertyByID: 'updatePropertyByID',\n deletePropertyByID: 'deletePropertyByID',\n updateStylesByID: 'updateStylesByID',\n updateInnerHTMLByID: 'updateInnerHTMLByID',\n updateTextContentByID: 'updateTextContentByID',\n dangerouslyReplaceNodeWithMarkupByID: 'dangerouslyReplaceNodeWithMarkupByID',\n dangerouslyProcessChildrenUpdates: 'dangerouslyProcessChildrenUpdates'\n});\n\nmodule.exports = ReactDOMIDOperations;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactDOMIDOperations.js\n ** module id = 130\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ReactDOMIDOperations.js?");
|
||
|
||
/***/ },
|
||
/* 131 */
|
||
/***/ 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 CSSPropertyOperations\n * @typechecks static-only\n */\n\n'use strict';\n\nvar CSSProperty = __webpack_require__(132);\nvar ExecutionEnvironment = __webpack_require__(77);\n\nvar camelizeStyleName = __webpack_require__(133);\nvar dangerousStyleValue = __webpack_require__(135);\nvar hyphenateStyleName = __webpack_require__(136);\nvar memoizeStringOnly = __webpack_require__(138);\nvar warning = __webpack_require__(82);\n\nvar processStyleName = memoizeStringOnly(function(styleName) {\n return hyphenateStyleName(styleName);\n});\n\nvar styleFloatAccessor = 'cssFloat';\nif (ExecutionEnvironment.canUseDOM) {\n // IE8 only supports accessing cssFloat (standard) as styleFloat\n if (document.documentElement.style.cssFloat === undefined) {\n styleFloatAccessor = 'styleFloat';\n }\n}\n\nif (\"production\" !== process.env.NODE_ENV) {\n // 'msTransform' is correct, but the other prefixes should be capitalized\n var badVendoredStyleNamePattern = /^(?:webkit|moz|o)[A-Z]/;\n\n // style values shouldn't contain a semicolon\n var badStyleValueWithSemicolonPattern = /;\\s*$/;\n\n var warnedStyleNames = {};\n var warnedStyleValues = {};\n\n var warnHyphenatedStyleName = function(name) {\n if (warnedStyleNames.hasOwnProperty(name) && warnedStyleNames[name]) {\n return;\n }\n\n warnedStyleNames[name] = true;\n (\"production\" !== process.env.NODE_ENV ? warning(\n false,\n 'Unsupported style property %s. Did you mean %s?',\n name,\n camelizeStyleName(name)\n ) : null);\n };\n\n var warnBadVendoredStyleName = function(name) {\n if (warnedStyleNames.hasOwnProperty(name) && warnedStyleNames[name]) {\n return;\n }\n\n warnedStyleNames[name] = true;\n (\"production\" !== process.env.NODE_ENV ? warning(\n false,\n 'Unsupported vendor-prefixed style property %s. Did you mean %s?',\n name,\n name.charAt(0).toUpperCase() + name.slice(1)\n ) : null);\n };\n\n var warnStyleValueWithSemicolon = function(name, value) {\n if (warnedStyleValues.hasOwnProperty(value) && warnedStyleValues[value]) {\n return;\n }\n\n warnedStyleValues[value] = true;\n (\"production\" !== process.env.NODE_ENV ? warning(\n false,\n 'Style property values shouldn\\'t contain a semicolon. ' +\n 'Try \"%s: %s\" instead.',\n name,\n value.replace(badStyleValueWithSemicolonPattern, '')\n ) : null);\n };\n\n /**\n * @param {string} name\n * @param {*} value\n */\n var warnValidStyle = function(name, value) {\n if (name.indexOf('-') > -1) {\n warnHyphenatedStyleName(name);\n } else if (badVendoredStyleNamePattern.test(name)) {\n warnBadVendoredStyleName(name);\n } else if (badStyleValueWithSemicolonPattern.test(value)) {\n warnStyleValueWithSemicolon(name, value);\n }\n };\n}\n\n/**\n * Operations for dealing with CSS properties.\n */\nvar CSSPropertyOperations = {\n\n /**\n * Serializes a mapping of style properties for use as inline styles:\n *\n * > createMarkupForStyles({width: '200px', height: 0})\n * \"width:200px;height:0;\"\n *\n * Undefined values are ignored so that declarative programming is easier.\n * The result should be HTML-escaped before insertion into the DOM.\n *\n * @param {object} styles\n * @return {?string}\n */\n createMarkupForStyles: function(styles) {\n var serialized = '';\n for (var styleName in styles) {\n if (!styles.hasOwnProperty(styleName)) {\n continue;\n }\n var styleValue = styles[styleName];\n if (\"production\" !== process.env.NODE_ENV) {\n warnValidStyle(styleName, styleValue);\n }\n if (styleValue != null) {\n serialized += processStyleName(styleName) + ':';\n serialized += dangerousStyleValue(styleName, styleValue) + ';';\n }\n }\n return serialized || null;\n },\n\n /**\n * Sets the value for multiple styles on a node. If a value is specified as\n * '' (empty string), the corresponding style property will be unset.\n *\n * @param {DOMElement} node\n * @param {object} styles\n */\n setValueForStyles: function(node, styles) {\n var style = node.style;\n for (var styleName in styles) {\n if (!styles.hasOwnProperty(styleName)) {\n continue;\n }\n if (\"production\" !== process.env.NODE_ENV) {\n warnValidStyle(styleName, styles[styleName]);\n }\n var styleValue = dangerousStyleValue(styleName, styles[styleName]);\n if (styleName === 'float') {\n styleName = styleFloatAccessor;\n }\n if (styleValue) {\n style[styleName] = styleValue;\n } else {\n var expansion = CSSProperty.shorthandPropertyExpansions[styleName];\n if (expansion) {\n // Shorthand property that IE8 won't like unsetting, so unset each\n // component to placate it\n for (var individualStyleName in expansion) {\n style[individualStyleName] = '';\n }\n } else {\n style[styleName] = '';\n }\n }\n }\n }\n\n};\n\nmodule.exports = CSSPropertyOperations;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/CSSPropertyOperations.js\n ** module id = 131\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/CSSPropertyOperations.js?");
|
||
|
||
/***/ },
|
||
/* 132 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("/**\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 CSSProperty\n */\n\n'use strict';\n\n/**\n * CSS properties which accept numbers but are not in units of \"px\".\n */\nvar isUnitlessNumber = {\n boxFlex: true,\n boxFlexGroup: true,\n columnCount: true,\n flex: true,\n flexGrow: true,\n flexPositive: true,\n flexShrink: true,\n flexNegative: true,\n fontWeight: true,\n lineClamp: true,\n lineHeight: true,\n opacity: true,\n order: true,\n orphans: true,\n widows: true,\n zIndex: true,\n zoom: true,\n\n // SVG-related properties\n fillOpacity: true,\n strokeDashoffset: true,\n strokeOpacity: true,\n strokeWidth: true\n};\n\n/**\n * @param {string} prefix vendor-specific prefix, eg: Webkit\n * @param {string} key style name, eg: transitionDuration\n * @return {string} style name prefixed with `prefix`, properly camelCased, eg:\n * WebkitTransitionDuration\n */\nfunction prefixKey(prefix, key) {\n return prefix + key.charAt(0).toUpperCase() + key.substring(1);\n}\n\n/**\n * Support style names that may come passed in prefixed by adding permutations\n * of vendor prefixes.\n */\nvar prefixes = ['Webkit', 'ms', 'Moz', 'O'];\n\n// Using Object.keys here, or else the vanilla for-in loop makes IE8 go into an\n// infinite loop, because it iterates over the newly added props too.\nObject.keys(isUnitlessNumber).forEach(function(prop) {\n prefixes.forEach(function(prefix) {\n isUnitlessNumber[prefixKey(prefix, prop)] = isUnitlessNumber[prop];\n });\n});\n\n/**\n * Most style properties can be unset by doing .style[prop] = '' but IE8\n * doesn't like doing that with shorthand properties so for the properties that\n * IE8 breaks on, which are listed here, we instead unset each of the\n * individual properties. See http://bugs.jquery.com/ticket/12385.\n * The 4-value 'clock' properties like margin, padding, border-width seem to\n * behave without any problems. Curiously, list-style works too without any\n * special prodding.\n */\nvar shorthandPropertyExpansions = {\n background: {\n backgroundImage: true,\n backgroundPosition: true,\n backgroundRepeat: true,\n backgroundColor: true\n },\n border: {\n borderWidth: true,\n borderStyle: true,\n borderColor: true\n },\n borderBottom: {\n borderBottomWidth: true,\n borderBottomStyle: true,\n borderBottomColor: true\n },\n borderLeft: {\n borderLeftWidth: true,\n borderLeftStyle: true,\n borderLeftColor: true\n },\n borderRight: {\n borderRightWidth: true,\n borderRightStyle: true,\n borderRightColor: true\n },\n borderTop: {\n borderTopWidth: true,\n borderTopStyle: true,\n borderTopColor: true\n },\n font: {\n fontStyle: true,\n fontVariant: true,\n fontWeight: true,\n fontSize: true,\n lineHeight: true,\n fontFamily: true\n }\n};\n\nvar CSSProperty = {\n isUnitlessNumber: isUnitlessNumber,\n shorthandPropertyExpansions: shorthandPropertyExpansions\n};\n\nmodule.exports = CSSProperty;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/CSSProperty.js\n ** module id = 132\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/CSSProperty.js?");
|
||
|
||
/***/ },
|
||
/* 133 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\n * Copyright 2014-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 camelizeStyleName\n * @typechecks\n */\n\n\"use strict\";\n\nvar camelize = __webpack_require__(134);\n\nvar msPattern = /^-ms-/;\n\n/**\n * Camelcases a hyphenated CSS property name, for example:\n *\n * > camelizeStyleName('background-color')\n * < \"backgroundColor\"\n * > camelizeStyleName('-moz-transition')\n * < \"MozTransition\"\n * > camelizeStyleName('-ms-transition')\n * < \"msTransition\"\n *\n * As Andi Smith suggests\n * (http://www.andismith.com/blog/2012/02/modernizr-prefixed/), an `-ms` prefix\n * is converted to lowercase `ms`.\n *\n * @param {string} string\n * @return {string}\n */\nfunction camelizeStyleName(string) {\n return camelize(string.replace(msPattern, 'ms-'));\n}\n\nmodule.exports = camelizeStyleName;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/camelizeStyleName.js\n ** module id = 133\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/camelizeStyleName.js?");
|
||
|
||
/***/ },
|
||
/* 134 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("/**\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 camelize\n * @typechecks\n */\n\nvar _hyphenPattern = /-(.)/g;\n\n/**\n * Camelcases a hyphenated string, for example:\n *\n * > camelize('background-color')\n * < \"backgroundColor\"\n *\n * @param {string} string\n * @return {string}\n */\nfunction camelize(string) {\n return string.replace(_hyphenPattern, function(_, character) {\n return character.toUpperCase();\n });\n}\n\nmodule.exports = camelize;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/camelize.js\n ** module id = 134\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/camelize.js?");
|
||
|
||
/***/ },
|
||
/* 135 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\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 dangerousStyleValue\n * @typechecks static-only\n */\n\n'use strict';\n\nvar CSSProperty = __webpack_require__(132);\n\nvar isUnitlessNumber = CSSProperty.isUnitlessNumber;\n\n/**\n * Convert a value into the proper css writable value. The style name `name`\n * should be logical (no hyphens), as specified\n * in `CSSProperty.isUnitlessNumber`.\n *\n * @param {string} name CSS property name such as `topMargin`.\n * @param {*} value CSS property value such as `10px`.\n * @return {string} Normalized style value with dimensions applied.\n */\nfunction dangerousStyleValue(name, value) {\n // Note that we've removed escapeTextForBrowser() calls here since the\n // whole string will be escaped when the attribute is injected into\n // the markup. If you provide unsafe user data here they can inject\n // arbitrary CSS which may be problematic (I couldn't repro this):\n // https://www.owasp.org/index.php/XSS_Filter_Evasion_Cheat_Sheet\n // http://www.thespanner.co.uk/2007/11/26/ultimate-xss-css-injection/\n // This is not an XSS hole but instead a potential CSS injection issue\n // which has lead to a greater discussion about how we're going to\n // trust URLs moving forward. See #2115901\n\n var isEmpty = value == null || typeof value === 'boolean' || value === '';\n if (isEmpty) {\n return '';\n }\n\n var isNonNumeric = isNaN(value);\n if (isNonNumeric || value === 0 ||\n isUnitlessNumber.hasOwnProperty(name) && isUnitlessNumber[name]) {\n return '' + value; // cast to string\n }\n\n if (typeof value === 'string') {\n value = value.trim();\n }\n return value + 'px';\n}\n\nmodule.exports = dangerousStyleValue;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/dangerousStyleValue.js\n ** module id = 135\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/dangerousStyleValue.js?");
|
||
|
||
/***/ },
|
||
/* 136 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\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 hyphenateStyleName\n * @typechecks\n */\n\n\"use strict\";\n\nvar hyphenate = __webpack_require__(137);\n\nvar msPattern = /^ms-/;\n\n/**\n * Hyphenates a camelcased CSS property name, for example:\n *\n * > hyphenateStyleName('backgroundColor')\n * < \"background-color\"\n * > hyphenateStyleName('MozTransition')\n * < \"-moz-transition\"\n * > hyphenateStyleName('msTransition')\n * < \"-ms-transition\"\n *\n * As Modernizr suggests (http://modernizr.com/docs/#prefixed), an `ms` prefix\n * is converted to `-ms-`.\n *\n * @param {string} string\n * @return {string}\n */\nfunction hyphenateStyleName(string) {\n return hyphenate(string).replace(msPattern, '-ms-');\n}\n\nmodule.exports = hyphenateStyleName;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/hyphenateStyleName.js\n ** module id = 136\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/hyphenateStyleName.js?");
|
||
|
||
/***/ },
|
||
/* 137 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("/**\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 hyphenate\n * @typechecks\n */\n\nvar _uppercasePattern = /([A-Z])/g;\n\n/**\n * Hyphenates a camelcased string, for example:\n *\n * > hyphenate('backgroundColor')\n * < \"background-color\"\n *\n * For CSS style names, use `hyphenateStyleName` instead which works properly\n * with all vendor prefixes, including `ms`.\n *\n * @param {string} string\n * @return {string}\n */\nfunction hyphenate(string) {\n return string.replace(_uppercasePattern, '-$1').toLowerCase();\n}\n\nmodule.exports = hyphenate;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/hyphenate.js\n ** module id = 137\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/hyphenate.js?");
|
||
|
||
/***/ },
|
||
/* 138 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("/**\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 memoizeStringOnly\n * @typechecks static-only\n */\n\n'use strict';\n\n/**\n * Memoizes the return value of a function that accepts one string argument.\n *\n * @param {function} callback\n * @return {function}\n */\nfunction memoizeStringOnly(callback) {\n var cache = {};\n return function(string) {\n if (!cache.hasOwnProperty(string)) {\n cache[string] = callback.call(this, string);\n }\n return cache[string];\n };\n}\n\nmodule.exports = memoizeStringOnly;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/memoizeStringOnly.js\n ** module id = 138\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/memoizeStringOnly.js?");
|
||
|
||
/***/ },
|
||
/* 139 */
|
||
/***/ 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 DOMChildrenOperations\n * @typechecks static-only\n */\n\n'use strict';\n\nvar Danger = __webpack_require__(140);\nvar ReactMultiChildUpdateTypes = __webpack_require__(145);\n\nvar setTextContent = __webpack_require__(146);\nvar invariant = __webpack_require__(64);\n\n/**\n * Inserts `childNode` as a child of `parentNode` at the `index`.\n *\n * @param {DOMElement} parentNode Parent node in which to insert.\n * @param {DOMElement} childNode Child node to insert.\n * @param {number} index Index at which to insert the child.\n * @internal\n */\nfunction insertChildAt(parentNode, childNode, index) {\n // By exploiting arrays returning `undefined` for an undefined index, we can\n // rely exclusively on `insertBefore(node, null)` instead of also using\n // `appendChild(node)`. However, using `undefined` is not allowed by all\n // browsers so we must replace it with `null`.\n parentNode.insertBefore(\n childNode,\n parentNode.childNodes[index] || null\n );\n}\n\n/**\n * Operations for updating with DOM children.\n */\nvar DOMChildrenOperations = {\n\n dangerouslyReplaceNodeWithMarkup: Danger.dangerouslyReplaceNodeWithMarkup,\n\n updateTextContent: setTextContent,\n\n /**\n * Updates a component's children by processing a series of updates. The\n * update configurations are each expected to have a `parentNode` property.\n *\n * @param {array<object>} updates List of update configurations.\n * @param {array<string>} markupList List of markup strings.\n * @internal\n */\n processUpdates: function(updates, markupList) {\n var update;\n // Mapping from parent IDs to initial child orderings.\n var initialChildren = null;\n // List of children that will be moved or removed.\n var updatedChildren = null;\n\n for (var i = 0; i < updates.length; i++) {\n update = updates[i];\n if (update.type === ReactMultiChildUpdateTypes.MOVE_EXISTING ||\n update.type === ReactMultiChildUpdateTypes.REMOVE_NODE) {\n var updatedIndex = update.fromIndex;\n var updatedChild = update.parentNode.childNodes[updatedIndex];\n var parentID = update.parentID;\n\n (\"production\" !== process.env.NODE_ENV ? invariant(\n updatedChild,\n 'processUpdates(): Unable to find child %s of element. This ' +\n 'probably means the DOM was unexpectedly mutated (e.g., by the ' +\n 'browser), usually due to forgetting a <tbody> when using tables, ' +\n 'nesting tags like <form>, <p>, or <a>, or using non-SVG elements ' +\n 'in an <svg> parent. Try inspecting the child nodes of the element ' +\n 'with React ID `%s`.',\n updatedIndex,\n parentID\n ) : invariant(updatedChild));\n\n initialChildren = initialChildren || {};\n initialChildren[parentID] = initialChildren[parentID] || [];\n initialChildren[parentID][updatedIndex] = updatedChild;\n\n updatedChildren = updatedChildren || [];\n updatedChildren.push(updatedChild);\n }\n }\n\n var renderedMarkup = Danger.dangerouslyRenderMarkup(markupList);\n\n // Remove updated children first so that `toIndex` is consistent.\n if (updatedChildren) {\n for (var j = 0; j < updatedChildren.length; j++) {\n updatedChildren[j].parentNode.removeChild(updatedChildren[j]);\n }\n }\n\n for (var k = 0; k < updates.length; k++) {\n update = updates[k];\n switch (update.type) {\n case ReactMultiChildUpdateTypes.INSERT_MARKUP:\n insertChildAt(\n update.parentNode,\n renderedMarkup[update.markupIndex],\n update.toIndex\n );\n break;\n case ReactMultiChildUpdateTypes.MOVE_EXISTING:\n insertChildAt(\n update.parentNode,\n initialChildren[update.parentID][update.fromIndex],\n update.toIndex\n );\n break;\n case ReactMultiChildUpdateTypes.TEXT_CONTENT:\n setTextContent(\n update.parentNode,\n update.textContent\n );\n break;\n case ReactMultiChildUpdateTypes.REMOVE_NODE:\n // Already removed by the for-loop above.\n break;\n }\n }\n }\n\n};\n\nmodule.exports = DOMChildrenOperations;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/DOMChildrenOperations.js\n ** module id = 139\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/DOMChildrenOperations.js?");
|
||
|
||
/***/ },
|
||
/* 140 */
|
||
/***/ 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 Danger\n * @typechecks static-only\n */\n\n/*jslint evil: true, sub: true */\n\n'use strict';\n\nvar ExecutionEnvironment = __webpack_require__(77);\n\nvar createNodesFromMarkup = __webpack_require__(141);\nvar emptyFunction = __webpack_require__(83);\nvar getMarkupWrap = __webpack_require__(144);\nvar invariant = __webpack_require__(64);\n\nvar OPEN_TAG_NAME_EXP = /^(<[^ \\/>]+)/;\nvar RESULT_INDEX_ATTR = 'data-danger-index';\n\n/**\n * Extracts the `nodeName` from a string of markup.\n *\n * NOTE: Extracting the `nodeName` does not require a regular expression match\n * because we make assumptions about React-generated markup (i.e. there are no\n * spaces surrounding the opening tag and there is at least one attribute).\n *\n * @param {string} markup String of markup.\n * @return {string} Node name of the supplied markup.\n * @see http://jsperf.com/extract-nodename\n */\nfunction getNodeName(markup) {\n return markup.substring(1, markup.indexOf(' '));\n}\n\nvar Danger = {\n\n /**\n * Renders markup into an array of nodes. The markup is expected to render\n * into a list of root nodes. Also, the length of `resultList` and\n * `markupList` should be the same.\n *\n * @param {array<string>} markupList List of markup strings to render.\n * @return {array<DOMElement>} List of rendered nodes.\n * @internal\n */\n dangerouslyRenderMarkup: function(markupList) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n ExecutionEnvironment.canUseDOM,\n 'dangerouslyRenderMarkup(...): Cannot render markup in a worker ' +\n 'thread. Make sure `window` and `document` are available globally ' +\n 'before requiring React when unit testing or use ' +\n 'React.renderToString for server rendering.'\n ) : invariant(ExecutionEnvironment.canUseDOM));\n var nodeName;\n var markupByNodeName = {};\n // Group markup by `nodeName` if a wrap is necessary, else by '*'.\n for (var i = 0; i < markupList.length; i++) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n markupList[i],\n 'dangerouslyRenderMarkup(...): Missing markup.'\n ) : invariant(markupList[i]));\n nodeName = getNodeName(markupList[i]);\n nodeName = getMarkupWrap(nodeName) ? nodeName : '*';\n markupByNodeName[nodeName] = markupByNodeName[nodeName] || [];\n markupByNodeName[nodeName][i] = markupList[i];\n }\n var resultList = [];\n var resultListAssignmentCount = 0;\n for (nodeName in markupByNodeName) {\n if (!markupByNodeName.hasOwnProperty(nodeName)) {\n continue;\n }\n var markupListByNodeName = markupByNodeName[nodeName];\n\n // This for-in loop skips the holes of the sparse array. The order of\n // iteration should follow the order of assignment, which happens to match\n // numerical index order, but we don't rely on that.\n var resultIndex;\n for (resultIndex in markupListByNodeName) {\n if (markupListByNodeName.hasOwnProperty(resultIndex)) {\n var markup = markupListByNodeName[resultIndex];\n\n // Push the requested markup with an additional RESULT_INDEX_ATTR\n // attribute. If the markup does not start with a < character, it\n // will be discarded below (with an appropriate console.error).\n markupListByNodeName[resultIndex] = markup.replace(\n OPEN_TAG_NAME_EXP,\n // This index will be parsed back out below.\n '$1 ' + RESULT_INDEX_ATTR + '=\"' + resultIndex + '\" '\n );\n }\n }\n\n // Render each group of markup with similar wrapping `nodeName`.\n var renderNodes = createNodesFromMarkup(\n markupListByNodeName.join(''),\n emptyFunction // Do nothing special with <script> tags.\n );\n\n for (var j = 0; j < renderNodes.length; ++j) {\n var renderNode = renderNodes[j];\n if (renderNode.hasAttribute &&\n renderNode.hasAttribute(RESULT_INDEX_ATTR)) {\n\n resultIndex = +renderNode.getAttribute(RESULT_INDEX_ATTR);\n renderNode.removeAttribute(RESULT_INDEX_ATTR);\n\n (\"production\" !== process.env.NODE_ENV ? invariant(\n !resultList.hasOwnProperty(resultIndex),\n 'Danger: Assigning to an already-occupied result index.'\n ) : invariant(!resultList.hasOwnProperty(resultIndex)));\n\n resultList[resultIndex] = renderNode;\n\n // This should match resultList.length and markupList.length when\n // we're done.\n resultListAssignmentCount += 1;\n\n } else if (\"production\" !== process.env.NODE_ENV) {\n console.error(\n 'Danger: Discarding unexpected node:',\n renderNode\n );\n }\n }\n }\n\n // Although resultList was populated out of order, it should now be a dense\n // array.\n (\"production\" !== process.env.NODE_ENV ? invariant(\n resultListAssignmentCount === resultList.length,\n 'Danger: Did not assign to every index of resultList.'\n ) : invariant(resultListAssignmentCount === resultList.length));\n\n (\"production\" !== process.env.NODE_ENV ? invariant(\n resultList.length === markupList.length,\n 'Danger: Expected markup to render %s nodes, but rendered %s.',\n markupList.length,\n resultList.length\n ) : invariant(resultList.length === markupList.length));\n\n return resultList;\n },\n\n /**\n * Replaces a node with a string of markup at its current position within its\n * parent. The markup must render into a single root node.\n *\n * @param {DOMElement} oldChild Child node to replace.\n * @param {string} markup Markup to render in place of the child node.\n * @internal\n */\n dangerouslyReplaceNodeWithMarkup: function(oldChild, markup) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n ExecutionEnvironment.canUseDOM,\n 'dangerouslyReplaceNodeWithMarkup(...): Cannot render markup in a ' +\n 'worker thread. Make sure `window` and `document` are available ' +\n 'globally before requiring React when unit testing or use ' +\n 'React.renderToString for server rendering.'\n ) : invariant(ExecutionEnvironment.canUseDOM));\n (\"production\" !== process.env.NODE_ENV ? invariant(markup, 'dangerouslyReplaceNodeWithMarkup(...): Missing markup.') : invariant(markup));\n (\"production\" !== process.env.NODE_ENV ? invariant(\n oldChild.tagName.toLowerCase() !== 'html',\n 'dangerouslyReplaceNodeWithMarkup(...): Cannot replace markup of the ' +\n '<html> node. This is because browser quirks make this unreliable ' +\n 'and/or slow. If you want to render to the root you must use ' +\n 'server rendering. See React.renderToString().'\n ) : invariant(oldChild.tagName.toLowerCase() !== 'html'));\n\n var newChild = createNodesFromMarkup(markup, emptyFunction)[0];\n oldChild.parentNode.replaceChild(newChild, oldChild);\n }\n\n};\n\nmodule.exports = Danger;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/Danger.js\n ** module id = 140\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/Danger.js?");
|
||
|
||
/***/ },
|
||
/* 141 */
|
||
/***/ 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 createNodesFromMarkup\n * @typechecks\n */\n\n/*jslint evil: true, sub: true */\n\nvar ExecutionEnvironment = __webpack_require__(77);\n\nvar createArrayFromMixed = __webpack_require__(142);\nvar getMarkupWrap = __webpack_require__(144);\nvar invariant = __webpack_require__(64);\n\n/**\n * Dummy container used to render all markup.\n */\nvar dummyNode =\n ExecutionEnvironment.canUseDOM ? document.createElement('div') : null;\n\n/**\n * Pattern used by `getNodeName`.\n */\nvar nodeNamePattern = /^\\s*<(\\w+)/;\n\n/**\n * Extracts the `nodeName` of the first element in a string of markup.\n *\n * @param {string} markup String of markup.\n * @return {?string} Node name of the supplied markup.\n */\nfunction getNodeName(markup) {\n var nodeNameMatch = markup.match(nodeNamePattern);\n return nodeNameMatch && nodeNameMatch[1].toLowerCase();\n}\n\n/**\n * Creates an array containing the nodes rendered from the supplied markup. The\n * optionally supplied `handleScript` function will be invoked once for each\n * <script> element that is rendered. If no `handleScript` function is supplied,\n * an exception is thrown if any <script> elements are rendered.\n *\n * @param {string} markup A string of valid HTML markup.\n * @param {?function} handleScript Invoked once for each rendered <script>.\n * @return {array<DOMElement|DOMTextNode>} An array of rendered nodes.\n */\nfunction createNodesFromMarkup(markup, handleScript) {\n var node = dummyNode;\n (\"production\" !== process.env.NODE_ENV ? invariant(!!dummyNode, 'createNodesFromMarkup dummy not initialized') : invariant(!!dummyNode));\n var nodeName = getNodeName(markup);\n\n var wrap = nodeName && getMarkupWrap(nodeName);\n if (wrap) {\n node.innerHTML = wrap[1] + markup + wrap[2];\n\n var wrapDepth = wrap[0];\n while (wrapDepth--) {\n node = node.lastChild;\n }\n } else {\n node.innerHTML = markup;\n }\n\n var scripts = node.getElementsByTagName('script');\n if (scripts.length) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n handleScript,\n 'createNodesFromMarkup(...): Unexpected <script> element rendered.'\n ) : invariant(handleScript));\n createArrayFromMixed(scripts).forEach(handleScript);\n }\n\n var nodes = createArrayFromMixed(node.childNodes);\n while (node.lastChild) {\n node.removeChild(node.lastChild);\n }\n return nodes;\n}\n\nmodule.exports = createNodesFromMarkup;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/createNodesFromMarkup.js\n ** module id = 141\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/createNodesFromMarkup.js?");
|
||
|
||
/***/ },
|
||
/* 142 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\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 createArrayFromMixed\n * @typechecks\n */\n\nvar toArray = __webpack_require__(143);\n\n/**\n * Perform a heuristic test to determine if an object is \"array-like\".\n *\n * A monk asked Joshu, a Zen master, \"Has a dog Buddha nature?\"\n * Joshu replied: \"Mu.\"\n *\n * This function determines if its argument has \"array nature\": it returns\n * true if the argument is an actual array, an `arguments' object, or an\n * HTMLCollection (e.g. node.childNodes or node.getElementsByTagName()).\n *\n * It will return false for other array-like objects like Filelist.\n *\n * @param {*} obj\n * @return {boolean}\n */\nfunction hasArrayNature(obj) {\n return (\n // not null/false\n !!obj &&\n // arrays are objects, NodeLists are functions in Safari\n (typeof obj == 'object' || typeof obj == 'function') &&\n // quacks like an array\n ('length' in obj) &&\n // not window\n !('setInterval' in obj) &&\n // no DOM node should be considered an array-like\n // a 'select' element has 'length' and 'item' properties on IE8\n (typeof obj.nodeType != 'number') &&\n (\n // a real array\n (// HTMLCollection/NodeList\n (Array.isArray(obj) ||\n // arguments\n ('callee' in obj) || 'item' in obj))\n )\n );\n}\n\n/**\n * Ensure that the argument is an array by wrapping it in an array if it is not.\n * Creates a copy of the argument if it is already an array.\n *\n * This is mostly useful idiomatically:\n *\n * var createArrayFromMixed = require('createArrayFromMixed');\n *\n * function takesOneOrMoreThings(things) {\n * things = createArrayFromMixed(things);\n * ...\n * }\n *\n * This allows you to treat `things' as an array, but accept scalars in the API.\n *\n * If you need to convert an array-like object, like `arguments`, into an array\n * use toArray instead.\n *\n * @param {*} obj\n * @return {array}\n */\nfunction createArrayFromMixed(obj) {\n if (!hasArrayNature(obj)) {\n return [obj];\n } else if (Array.isArray(obj)) {\n return obj.slice();\n } else {\n return toArray(obj);\n }\n}\n\nmodule.exports = createArrayFromMixed;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/createArrayFromMixed.js\n ** module id = 142\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/createArrayFromMixed.js?");
|
||
|
||
/***/ },
|
||
/* 143 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/* WEBPACK VAR INJECTION */(function(process) {/**\n * Copyright 2014-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 toArray\n * @typechecks\n */\n\nvar invariant = __webpack_require__(64);\n\n/**\n * Convert array-like objects to arrays.\n *\n * This API assumes the caller knows the contents of the data type. For less\n * well defined inputs use createArrayFromMixed.\n *\n * @param {object|function|filelist} obj\n * @return {array}\n */\nfunction toArray(obj) {\n var length = obj.length;\n\n // Some browse builtin objects can report typeof 'function' (e.g. NodeList in\n // old versions of Safari).\n (\"production\" !== process.env.NODE_ENV ? invariant(\n !Array.isArray(obj) &&\n (typeof obj === 'object' || typeof obj === 'function'),\n 'toArray: Array-like object expected'\n ) : invariant(!Array.isArray(obj) &&\n (typeof obj === 'object' || typeof obj === 'function')));\n\n (\"production\" !== process.env.NODE_ENV ? invariant(\n typeof length === 'number',\n 'toArray: Object needs a length property'\n ) : invariant(typeof length === 'number'));\n\n (\"production\" !== process.env.NODE_ENV ? invariant(\n length === 0 ||\n (length - 1) in obj,\n 'toArray: Object should have keys for indices'\n ) : invariant(length === 0 ||\n (length - 1) in obj));\n\n // Old IE doesn't give collections access to hasOwnProperty. Assume inputs\n // without method will throw during the slice call and skip straight to the\n // fallback.\n if (obj.hasOwnProperty) {\n try {\n return Array.prototype.slice.call(obj);\n } catch (e) {\n // IE < 9 does not support Array#slice on collections objects\n }\n }\n\n // Fall back to copying key by key. This assumes all keys have a value,\n // so will not preserve sparsely populated inputs.\n var ret = Array(length);\n for (var ii = 0; ii < length; ii++) {\n ret[ii] = obj[ii];\n }\n return ret;\n}\n\nmodule.exports = toArray;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/toArray.js\n ** module id = 143\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/toArray.js?");
|
||
|
||
/***/ },
|
||
/* 144 */
|
||
/***/ 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 getMarkupWrap\n */\n\nvar ExecutionEnvironment = __webpack_require__(77);\n\nvar invariant = __webpack_require__(64);\n\n/**\n * Dummy container used to detect which wraps are necessary.\n */\nvar dummyNode =\n ExecutionEnvironment.canUseDOM ? document.createElement('div') : null;\n\n/**\n * Some browsers cannot use `innerHTML` to render certain elements standalone,\n * so we wrap them, render the wrapped nodes, then extract the desired node.\n *\n * In IE8, certain elements cannot render alone, so wrap all elements ('*').\n */\nvar shouldWrap = {\n // Force wrapping for SVG elements because if they get created inside a <div>,\n // they will be initialized in the wrong namespace (and will not display).\n 'circle': true,\n 'clipPath': true,\n 'defs': true,\n 'ellipse': true,\n 'g': true,\n 'line': true,\n 'linearGradient': true,\n 'path': true,\n 'polygon': true,\n 'polyline': true,\n 'radialGradient': true,\n 'rect': true,\n 'stop': true,\n 'text': true\n};\n\nvar selectWrap = [1, '<select multiple=\"true\">', '</select>'];\nvar tableWrap = [1, '<table>', '</table>'];\nvar trWrap = [3, '<table><tbody><tr>', '</tr></tbody></table>'];\n\nvar svgWrap = [1, '<svg>', '</svg>'];\n\nvar markupWrap = {\n '*': [1, '?<div>', '</div>'],\n\n 'area': [1, '<map>', '</map>'],\n 'col': [2, '<table><tbody></tbody><colgroup>', '</colgroup></table>'],\n 'legend': [1, '<fieldset>', '</fieldset>'],\n 'param': [1, '<object>', '</object>'],\n 'tr': [2, '<table><tbody>', '</tbody></table>'],\n\n 'optgroup': selectWrap,\n 'option': selectWrap,\n\n 'caption': tableWrap,\n 'colgroup': tableWrap,\n 'tbody': tableWrap,\n 'tfoot': tableWrap,\n 'thead': tableWrap,\n\n 'td': trWrap,\n 'th': trWrap,\n\n 'circle': svgWrap,\n 'clipPath': svgWrap,\n 'defs': svgWrap,\n 'ellipse': svgWrap,\n 'g': svgWrap,\n 'line': svgWrap,\n 'linearGradient': svgWrap,\n 'path': svgWrap,\n 'polygon': svgWrap,\n 'polyline': svgWrap,\n 'radialGradient': svgWrap,\n 'rect': svgWrap,\n 'stop': svgWrap,\n 'text': svgWrap\n};\n\n/**\n * Gets the markup wrap configuration for the supplied `nodeName`.\n *\n * NOTE: This lazily detects which wraps are necessary for the current browser.\n *\n * @param {string} nodeName Lowercase `nodeName`.\n * @return {?array} Markup wrap configuration, if applicable.\n */\nfunction getMarkupWrap(nodeName) {\n (\"production\" !== process.env.NODE_ENV ? invariant(!!dummyNode, 'Markup wrapping node not initialized') : invariant(!!dummyNode));\n if (!markupWrap.hasOwnProperty(nodeName)) {\n nodeName = '*';\n }\n if (!shouldWrap.hasOwnProperty(nodeName)) {\n if (nodeName === '*') {\n dummyNode.innerHTML = '<link />';\n } else {\n dummyNode.innerHTML = '<' + nodeName + '></' + nodeName + '>';\n }\n shouldWrap[nodeName] = !dummyNode.firstChild;\n }\n return shouldWrap[nodeName] ? markupWrap[nodeName] : null;\n}\n\n\nmodule.exports = getMarkupWrap;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/getMarkupWrap.js\n ** module id = 144\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/getMarkupWrap.js?");
|
||
|
||
/***/ },
|
||
/* 145 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\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 ReactMultiChildUpdateTypes\n */\n\n'use strict';\n\nvar keyMirror = __webpack_require__(67);\n\n/**\n * When a component's children are updated, a series of update configuration\n * objects are created in order to batch and serialize the required changes.\n *\n * Enumerates all the possible types of update configurations.\n *\n * @internal\n */\nvar ReactMultiChildUpdateTypes = keyMirror({\n INSERT_MARKUP: null,\n MOVE_EXISTING: null,\n REMOVE_NODE: null,\n TEXT_CONTENT: null\n});\n\nmodule.exports = ReactMultiChildUpdateTypes;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactMultiChildUpdateTypes.js\n ** module id = 145\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ReactMultiChildUpdateTypes.js?");
|
||
|
||
/***/ },
|
||
/* 146 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\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 setTextContent\n */\n\n'use strict';\n\nvar ExecutionEnvironment = __webpack_require__(77);\nvar escapeTextContentForBrowser = __webpack_require__(128);\nvar setInnerHTML = __webpack_require__(114);\n\n/**\n * Set the textContent property of a node, ensuring that whitespace is preserved\n * even in IE8. innerText is a poor substitute for textContent and, among many\n * issues, inserts <br> instead of the literal newline chars. innerHTML behaves\n * as it should.\n *\n * @param {DOMElement} node\n * @param {string} text\n * @internal\n */\nvar setTextContent = function(node, text) {\n node.textContent = text;\n};\n\nif (ExecutionEnvironment.canUseDOM) {\n if (!('textContent' in document.documentElement)) {\n setTextContent = function(node, text) {\n setInnerHTML(node, escapeTextContentForBrowser(text));\n };\n }\n}\n\nmodule.exports = setTextContent;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/setTextContent.js\n ** module id = 146\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/setTextContent.js?");
|
||
|
||
/***/ },
|
||
/* 147 */
|
||
/***/ 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 ReactDOMComponent\n * @typechecks static-only\n */\n\n/* global hasOwnProperty:true */\n\n'use strict';\n\nvar CSSPropertyOperations = __webpack_require__(131);\nvar DOMProperty = __webpack_require__(63);\nvar DOMPropertyOperations = __webpack_require__(126);\nvar ReactBrowserEventEmitter = __webpack_require__(65);\nvar ReactComponentBrowserEnvironment =\n __webpack_require__(129);\nvar ReactMount = __webpack_require__(61);\nvar ReactMultiChild = __webpack_require__(148);\nvar ReactPerf = __webpack_require__(96);\n\nvar assign = __webpack_require__(75);\nvar escapeTextContentForBrowser = __webpack_require__(128);\nvar invariant = __webpack_require__(64);\nvar isEventSupported = __webpack_require__(76);\nvar keyOf = __webpack_require__(122);\nvar warning = __webpack_require__(82);\n\nvar deleteListener = ReactBrowserEventEmitter.deleteListener;\nvar listenTo = ReactBrowserEventEmitter.listenTo;\nvar registrationNameModules = ReactBrowserEventEmitter.registrationNameModules;\n\n// For quickly matching children type, to test if can be treated as content.\nvar CONTENT_TYPES = {'string': true, 'number': true};\n\nvar STYLE = keyOf({style: null});\n\nvar ELEMENT_NODE_TYPE = 1;\n\n/**\n * Optionally injectable operations for mutating the DOM\n */\nvar BackendIDOperations = null;\n\n/**\n * @param {?object} props\n */\nfunction assertValidProps(props) {\n if (!props) {\n return;\n }\n // Note the use of `==` which checks for null or undefined.\n if (props.dangerouslySetInnerHTML != null) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n props.children == null,\n 'Can only set one of `children` or `props.dangerouslySetInnerHTML`.'\n ) : invariant(props.children == null));\n (\"production\" !== process.env.NODE_ENV ? invariant(\n typeof props.dangerouslySetInnerHTML === 'object' &&\n '__html' in props.dangerouslySetInnerHTML,\n '`props.dangerouslySetInnerHTML` must be in the form `{__html: ...}`. ' +\n 'Please visit https://fb.me/react-invariant-dangerously-set-inner-html ' +\n 'for more information.'\n ) : invariant(typeof props.dangerouslySetInnerHTML === 'object' &&\n '__html' in props.dangerouslySetInnerHTML));\n }\n if (\"production\" !== process.env.NODE_ENV) {\n (\"production\" !== process.env.NODE_ENV ? warning(\n props.innerHTML == null,\n 'Directly setting property `innerHTML` is not permitted. ' +\n 'For more information, lookup documentation on `dangerouslySetInnerHTML`.'\n ) : null);\n (\"production\" !== process.env.NODE_ENV ? warning(\n !props.contentEditable || props.children == null,\n 'A component is `contentEditable` and contains `children` managed by ' +\n 'React. It is now your responsibility to guarantee that none of ' +\n 'those nodes are unexpectedly modified or duplicated. This is ' +\n 'probably not intentional.'\n ) : null);\n }\n (\"production\" !== process.env.NODE_ENV ? invariant(\n props.style == null || typeof props.style === 'object',\n 'The `style` prop expects a mapping from style properties to values, ' +\n 'not a string. For example, style={{marginRight: spacing + \\'em\\'}} when ' +\n 'using JSX.'\n ) : invariant(props.style == null || typeof props.style === 'object'));\n}\n\nfunction putListener(id, registrationName, listener, transaction) {\n if (\"production\" !== process.env.NODE_ENV) {\n // IE8 has no API for event capturing and the `onScroll` event doesn't\n // bubble.\n (\"production\" !== process.env.NODE_ENV ? warning(\n registrationName !== 'onScroll' || isEventSupported('scroll', true),\n 'This browser doesn\\'t support the `onScroll` event'\n ) : null);\n }\n var container = ReactMount.findReactContainerForID(id);\n if (container) {\n var doc = container.nodeType === ELEMENT_NODE_TYPE ?\n container.ownerDocument :\n container;\n listenTo(registrationName, doc);\n }\n transaction.getPutListenerQueue().enqueuePutListener(\n id,\n registrationName,\n listener\n );\n}\n\n// For HTML, certain tags should omit their close tag. We keep a whitelist for\n// those special cased tags.\n\nvar omittedCloseTags = {\n 'area': true,\n 'base': true,\n 'br': true,\n 'col': true,\n 'embed': true,\n 'hr': true,\n 'img': true,\n 'input': true,\n 'keygen': true,\n 'link': true,\n 'meta': true,\n 'param': true,\n 'source': true,\n 'track': true,\n 'wbr': true\n // NOTE: menuitem's close tag should be omitted, but that causes problems.\n};\n\n// We accept any tag to be rendered but since this gets injected into abitrary\n// HTML, we want to make sure that it's a safe tag.\n// http://www.w3.org/TR/REC-xml/#NT-Name\n\nvar VALID_TAG_REGEX = /^[a-zA-Z][a-zA-Z:_\\.\\-\\d]*$/; // Simplified subset\nvar validatedTagCache = {};\nvar hasOwnProperty = {}.hasOwnProperty;\n\nfunction validateDangerousTag(tag) {\n if (!hasOwnProperty.call(validatedTagCache, tag)) {\n (\"production\" !== process.env.NODE_ENV ? invariant(VALID_TAG_REGEX.test(tag), 'Invalid tag: %s', tag) : invariant(VALID_TAG_REGEX.test(tag)));\n validatedTagCache[tag] = true;\n }\n}\n\n/**\n * Creates a new React class that is idempotent and capable of containing other\n * React components. It accepts event listeners and DOM properties that are\n * valid according to `DOMProperty`.\n *\n * - Event listeners: `onClick`, `onMouseDown`, etc.\n * - DOM properties: `className`, `name`, `title`, etc.\n *\n * The `style` property functions differently from the DOM API. It accepts an\n * object mapping of style properties to values.\n *\n * @constructor ReactDOMComponent\n * @extends ReactMultiChild\n */\nfunction ReactDOMComponent(tag) {\n validateDangerousTag(tag);\n this._tag = tag;\n this._renderedChildren = null;\n this._previousStyleCopy = null;\n this._rootNodeID = null;\n}\n\nReactDOMComponent.displayName = 'ReactDOMComponent';\n\nReactDOMComponent.Mixin = {\n\n construct: function(element) {\n this._currentElement = element;\n },\n\n /**\n * Generates root tag markup then recurses. This method has side effects and\n * is not idempotent.\n *\n * @internal\n * @param {string} rootID The root DOM ID for this node.\n * @param {ReactReconcileTransaction|ReactServerRenderingTransaction} transaction\n * @return {string} The computed markup.\n */\n mountComponent: function(rootID, transaction, context) {\n this._rootNodeID = rootID;\n assertValidProps(this._currentElement.props);\n var closeTag = omittedCloseTags[this._tag] ? '' : '</' + this._tag + '>';\n return (\n this._createOpenTagMarkupAndPutListeners(transaction) +\n this._createContentMarkup(transaction, context) +\n closeTag\n );\n },\n\n /**\n * Creates markup for the open tag and all attributes.\n *\n * This method has side effects because events get registered.\n *\n * Iterating over object properties is faster than iterating over arrays.\n * @see http://jsperf.com/obj-vs-arr-iteration\n *\n * @private\n * @param {ReactReconcileTransaction|ReactServerRenderingTransaction} transaction\n * @return {string} Markup of opening tag.\n */\n _createOpenTagMarkupAndPutListeners: function(transaction) {\n var props = this._currentElement.props;\n var ret = '<' + this._tag;\n\n for (var propKey in props) {\n if (!props.hasOwnProperty(propKey)) {\n continue;\n }\n var propValue = props[propKey];\n if (propValue == null) {\n continue;\n }\n if (registrationNameModules.hasOwnProperty(propKey)) {\n putListener(this._rootNodeID, propKey, propValue, transaction);\n } else {\n if (propKey === STYLE) {\n if (propValue) {\n propValue = this._previousStyleCopy = assign({}, props.style);\n }\n propValue = CSSPropertyOperations.createMarkupForStyles(propValue);\n }\n var markup =\n DOMPropertyOperations.createMarkupForProperty(propKey, propValue);\n if (markup) {\n ret += ' ' + markup;\n }\n }\n }\n\n // For static pages, no need to put React ID and checksum. Saves lots of\n // bytes.\n if (transaction.renderToStaticMarkup) {\n return ret + '>';\n }\n\n var markupForID = DOMPropertyOperations.createMarkupForID(this._rootNodeID);\n return ret + ' ' + markupForID + '>';\n },\n\n /**\n * Creates markup for the content between the tags.\n *\n * @private\n * @param {ReactReconcileTransaction|ReactServerRenderingTransaction} transaction\n * @param {object} context\n * @return {string} Content markup.\n */\n _createContentMarkup: function(transaction, context) {\n var prefix = '';\n if (this._tag === 'listing' ||\n this._tag === 'pre' ||\n this._tag === 'textarea') {\n // Add an initial newline because browsers ignore the first newline in\n // a <listing>, <pre>, or <textarea> as an \"authoring convenience\" -- see\n // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inbody.\n prefix = '\\n';\n }\n\n var props = this._currentElement.props;\n\n // Intentional use of != to avoid catching zero/false.\n var innerHTML = props.dangerouslySetInnerHTML;\n if (innerHTML != null) {\n if (innerHTML.__html != null) {\n return prefix + innerHTML.__html;\n }\n } else {\n var contentToUse =\n CONTENT_TYPES[typeof props.children] ? props.children : null;\n var childrenToUse = contentToUse != null ? null : props.children;\n if (contentToUse != null) {\n return prefix + escapeTextContentForBrowser(contentToUse);\n } else if (childrenToUse != null) {\n var mountImages = this.mountChildren(\n childrenToUse,\n transaction,\n context\n );\n return prefix + mountImages.join('');\n }\n }\n return prefix;\n },\n\n receiveComponent: function(nextElement, transaction, context) {\n var prevElement = this._currentElement;\n this._currentElement = nextElement;\n this.updateComponent(transaction, prevElement, nextElement, context);\n },\n\n /**\n * Updates a native DOM component after it has already been allocated and\n * attached to the DOM. Reconciles the root DOM node, then recurses.\n *\n * @param {ReactReconcileTransaction} transaction\n * @param {ReactElement} prevElement\n * @param {ReactElement} nextElement\n * @internal\n * @overridable\n */\n updateComponent: function(transaction, prevElement, nextElement, context) {\n assertValidProps(this._currentElement.props);\n this._updateDOMProperties(prevElement.props, transaction);\n this._updateDOMChildren(prevElement.props, transaction, context);\n },\n\n /**\n * Reconciles the properties by detecting differences in property values and\n * updating the DOM as necessary. This function is probably the single most\n * critical path for performance optimization.\n *\n * TODO: Benchmark whether checking for changed values in memory actually\n * improves performance (especially statically positioned elements).\n * TODO: Benchmark the effects of putting this at the top since 99% of props\n * do not change for a given reconciliation.\n * TODO: Benchmark areas that can be improved with caching.\n *\n * @private\n * @param {object} lastProps\n * @param {ReactReconcileTransaction} transaction\n */\n _updateDOMProperties: function(lastProps, transaction) {\n var nextProps = this._currentElement.props;\n var propKey;\n var styleName;\n var styleUpdates;\n for (propKey in lastProps) {\n if (nextProps.hasOwnProperty(propKey) ||\n !lastProps.hasOwnProperty(propKey)) {\n continue;\n }\n if (propKey === STYLE) {\n var lastStyle = this._previousStyleCopy;\n for (styleName in lastStyle) {\n if (lastStyle.hasOwnProperty(styleName)) {\n styleUpdates = styleUpdates || {};\n styleUpdates[styleName] = '';\n }\n }\n this._previousStyleCopy = null;\n } else if (registrationNameModules.hasOwnProperty(propKey)) {\n deleteListener(this._rootNodeID, propKey);\n } else if (\n DOMProperty.isStandardName[propKey] ||\n DOMProperty.isCustomAttribute(propKey)) {\n BackendIDOperations.deletePropertyByID(\n this._rootNodeID,\n propKey\n );\n }\n }\n for (propKey in nextProps) {\n var nextProp = nextProps[propKey];\n var lastProp = propKey === STYLE ?\n this._previousStyleCopy :\n lastProps[propKey];\n if (!nextProps.hasOwnProperty(propKey) || nextProp === lastProp) {\n continue;\n }\n if (propKey === STYLE) {\n if (nextProp) {\n nextProp = this._previousStyleCopy = assign({}, nextProp);\n } else {\n this._previousStyleCopy = null;\n }\n if (lastProp) {\n // Unset styles on `lastProp` but not on `nextProp`.\n for (styleName in lastProp) {\n if (lastProp.hasOwnProperty(styleName) &&\n (!nextProp || !nextProp.hasOwnProperty(styleName))) {\n styleUpdates = styleUpdates || {};\n styleUpdates[styleName] = '';\n }\n }\n // Update styles that changed since `lastProp`.\n for (styleName in nextProp) {\n if (nextProp.hasOwnProperty(styleName) &&\n lastProp[styleName] !== nextProp[styleName]) {\n styleUpdates = styleUpdates || {};\n styleUpdates[styleName] = nextProp[styleName];\n }\n }\n } else {\n // Relies on `updateStylesByID` not mutating `styleUpdates`.\n styleUpdates = nextProp;\n }\n } else if (registrationNameModules.hasOwnProperty(propKey)) {\n putListener(this._rootNodeID, propKey, nextProp, transaction);\n } else if (\n DOMProperty.isStandardName[propKey] ||\n DOMProperty.isCustomAttribute(propKey)) {\n BackendIDOperations.updatePropertyByID(\n this._rootNodeID,\n propKey,\n nextProp\n );\n }\n }\n if (styleUpdates) {\n BackendIDOperations.updateStylesByID(\n this._rootNodeID,\n styleUpdates\n );\n }\n },\n\n /**\n * Reconciles the children with the various properties that affect the\n * children content.\n *\n * @param {object} lastProps\n * @param {ReactReconcileTransaction} transaction\n */\n _updateDOMChildren: function(lastProps, transaction, context) {\n var nextProps = this._currentElement.props;\n\n var lastContent =\n CONTENT_TYPES[typeof lastProps.children] ? lastProps.children : null;\n var nextContent =\n CONTENT_TYPES[typeof nextProps.children] ? nextProps.children : null;\n\n var lastHtml =\n lastProps.dangerouslySetInnerHTML &&\n lastProps.dangerouslySetInnerHTML.__html;\n var nextHtml =\n nextProps.dangerouslySetInnerHTML &&\n nextProps.dangerouslySetInnerHTML.__html;\n\n // Note the use of `!=` which checks for null or undefined.\n var lastChildren = lastContent != null ? null : lastProps.children;\n var nextChildren = nextContent != null ? null : nextProps.children;\n\n // If we're switching from children to content/html or vice versa, remove\n // the old content\n var lastHasContentOrHtml = lastContent != null || lastHtml != null;\n var nextHasContentOrHtml = nextContent != null || nextHtml != null;\n if (lastChildren != null && nextChildren == null) {\n this.updateChildren(null, transaction, context);\n } else if (lastHasContentOrHtml && !nextHasContentOrHtml) {\n this.updateTextContent('');\n }\n\n if (nextContent != null) {\n if (lastContent !== nextContent) {\n this.updateTextContent('' + nextContent);\n }\n } else if (nextHtml != null) {\n if (lastHtml !== nextHtml) {\n BackendIDOperations.updateInnerHTMLByID(\n this._rootNodeID,\n nextHtml\n );\n }\n } else if (nextChildren != null) {\n this.updateChildren(nextChildren, transaction, context);\n }\n },\n\n /**\n * Destroys all event registrations for this instance. Does not remove from\n * the DOM. That must be done by the parent.\n *\n * @internal\n */\n unmountComponent: function() {\n this.unmountChildren();\n ReactBrowserEventEmitter.deleteAllListeners(this._rootNodeID);\n ReactComponentBrowserEnvironment.unmountIDFromEnvironment(this._rootNodeID);\n this._rootNodeID = null;\n }\n\n};\n\nReactPerf.measureMethods(ReactDOMComponent, 'ReactDOMComponent', {\n mountComponent: 'mountComponent',\n updateComponent: 'updateComponent'\n});\n\nassign(\n ReactDOMComponent.prototype,\n ReactDOMComponent.Mixin,\n ReactMultiChild.Mixin\n);\n\nReactDOMComponent.injection = {\n injectIDOperations: function(IDOperations) {\n ReactDOMComponent.BackendIDOperations = BackendIDOperations = IDOperations;\n }\n};\n\nmodule.exports = ReactDOMComponent;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactDOMComponent.js\n ** module id = 147\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ReactDOMComponent.js?");
|
||
|
||
/***/ },
|
||
/* 148 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\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 ReactMultiChild\n * @typechecks static-only\n */\n\n'use strict';\n\nvar ReactComponentEnvironment = __webpack_require__(112);\nvar ReactMultiChildUpdateTypes = __webpack_require__(145);\n\nvar ReactReconciler = __webpack_require__(97);\nvar ReactChildReconciler = __webpack_require__(149);\n\n/**\n * Updating children of a component may trigger recursive updates. The depth is\n * used to batch recursive updates to render markup more efficiently.\n *\n * @type {number}\n * @private\n */\nvar updateDepth = 0;\n\n/**\n * Queue of update configuration objects.\n *\n * Each object has a `type` property that is in `ReactMultiChildUpdateTypes`.\n *\n * @type {array<object>}\n * @private\n */\nvar updateQueue = [];\n\n/**\n * Queue of markup to be rendered.\n *\n * @type {array<string>}\n * @private\n */\nvar markupQueue = [];\n\n/**\n * Enqueues markup to be rendered and inserted at a supplied index.\n *\n * @param {string} parentID ID of the parent component.\n * @param {string} markup Markup that renders into an element.\n * @param {number} toIndex Destination index.\n * @private\n */\nfunction enqueueMarkup(parentID, markup, toIndex) {\n // NOTE: Null values reduce hidden classes.\n updateQueue.push({\n parentID: parentID,\n parentNode: null,\n type: ReactMultiChildUpdateTypes.INSERT_MARKUP,\n markupIndex: markupQueue.push(markup) - 1,\n textContent: null,\n fromIndex: null,\n toIndex: toIndex\n });\n}\n\n/**\n * Enqueues moving an existing element to another index.\n *\n * @param {string} parentID ID of the parent component.\n * @param {number} fromIndex Source index of the existing element.\n * @param {number} toIndex Destination index of the element.\n * @private\n */\nfunction enqueueMove(parentID, fromIndex, toIndex) {\n // NOTE: Null values reduce hidden classes.\n updateQueue.push({\n parentID: parentID,\n parentNode: null,\n type: ReactMultiChildUpdateTypes.MOVE_EXISTING,\n markupIndex: null,\n textContent: null,\n fromIndex: fromIndex,\n toIndex: toIndex\n });\n}\n\n/**\n * Enqueues removing an element at an index.\n *\n * @param {string} parentID ID of the parent component.\n * @param {number} fromIndex Index of the element to remove.\n * @private\n */\nfunction enqueueRemove(parentID, fromIndex) {\n // NOTE: Null values reduce hidden classes.\n updateQueue.push({\n parentID: parentID,\n parentNode: null,\n type: ReactMultiChildUpdateTypes.REMOVE_NODE,\n markupIndex: null,\n textContent: null,\n fromIndex: fromIndex,\n toIndex: null\n });\n}\n\n/**\n * Enqueues setting the text content.\n *\n * @param {string} parentID ID of the parent component.\n * @param {string} textContent Text content to set.\n * @private\n */\nfunction enqueueTextContent(parentID, textContent) {\n // NOTE: Null values reduce hidden classes.\n updateQueue.push({\n parentID: parentID,\n parentNode: null,\n type: ReactMultiChildUpdateTypes.TEXT_CONTENT,\n markupIndex: null,\n textContent: textContent,\n fromIndex: null,\n toIndex: null\n });\n}\n\n/**\n * Processes any enqueued updates.\n *\n * @private\n */\nfunction processQueue() {\n if (updateQueue.length) {\n ReactComponentEnvironment.processChildrenUpdates(\n updateQueue,\n markupQueue\n );\n clearQueue();\n }\n}\n\n/**\n * Clears any enqueued updates.\n *\n * @private\n */\nfunction clearQueue() {\n updateQueue.length = 0;\n markupQueue.length = 0;\n}\n\n/**\n * ReactMultiChild are capable of reconciling multiple children.\n *\n * @class ReactMultiChild\n * @internal\n */\nvar ReactMultiChild = {\n\n /**\n * Provides common functionality for components that must reconcile multiple\n * children. This is used by `ReactDOMComponent` to mount, update, and\n * unmount child components.\n *\n * @lends {ReactMultiChild.prototype}\n */\n Mixin: {\n\n /**\n * Generates a \"mount image\" for each of the supplied children. In the case\n * of `ReactDOMComponent`, a mount image is a string of markup.\n *\n * @param {?object} nestedChildren Nested child maps.\n * @return {array} An array of mounted representations.\n * @internal\n */\n mountChildren: function(nestedChildren, transaction, context) {\n var children = ReactChildReconciler.instantiateChildren(\n nestedChildren, transaction, context\n );\n this._renderedChildren = children;\n var mountImages = [];\n var index = 0;\n for (var name in children) {\n if (children.hasOwnProperty(name)) {\n var child = children[name];\n // Inlined for performance, see `ReactInstanceHandles.createReactID`.\n var rootID = this._rootNodeID + name;\n var mountImage = ReactReconciler.mountComponent(\n child,\n rootID,\n transaction,\n context\n );\n child._mountIndex = index;\n mountImages.push(mountImage);\n index++;\n }\n }\n return mountImages;\n },\n\n /**\n * Replaces any rendered children with a text content string.\n *\n * @param {string} nextContent String of content.\n * @internal\n */\n updateTextContent: function(nextContent) {\n updateDepth++;\n var errorThrown = true;\n try {\n var prevChildren = this._renderedChildren;\n // Remove any rendered children.\n ReactChildReconciler.unmountChildren(prevChildren);\n // TODO: The setTextContent operation should be enough\n for (var name in prevChildren) {\n if (prevChildren.hasOwnProperty(name)) {\n this._unmountChildByName(prevChildren[name], name);\n }\n }\n // Set new text content.\n this.setTextContent(nextContent);\n errorThrown = false;\n } finally {\n updateDepth--;\n if (!updateDepth) {\n if (errorThrown) {\n clearQueue();\n } else {\n processQueue();\n }\n }\n }\n },\n\n /**\n * Updates the rendered children with new children.\n *\n * @param {?object} nextNestedChildren Nested child maps.\n * @param {ReactReconcileTransaction} transaction\n * @internal\n */\n updateChildren: function(nextNestedChildren, transaction, context) {\n updateDepth++;\n var errorThrown = true;\n try {\n this._updateChildren(nextNestedChildren, transaction, context);\n errorThrown = false;\n } finally {\n updateDepth--;\n if (!updateDepth) {\n if (errorThrown) {\n clearQueue();\n } else {\n processQueue();\n }\n }\n\n }\n },\n\n /**\n * Improve performance by isolating this hot code path from the try/catch\n * block in `updateChildren`.\n *\n * @param {?object} nextNestedChildren Nested child maps.\n * @param {ReactReconcileTransaction} transaction\n * @final\n * @protected\n */\n _updateChildren: function(nextNestedChildren, transaction, context) {\n var prevChildren = this._renderedChildren;\n var nextChildren = ReactChildReconciler.updateChildren(\n prevChildren, nextNestedChildren, transaction, context\n );\n this._renderedChildren = nextChildren;\n if (!nextChildren && !prevChildren) {\n return;\n }\n var name;\n // `nextIndex` will increment for each child in `nextChildren`, but\n // `lastIndex` will be the last index visited in `prevChildren`.\n var lastIndex = 0;\n var nextIndex = 0;\n for (name in nextChildren) {\n if (!nextChildren.hasOwnProperty(name)) {\n continue;\n }\n var prevChild = prevChildren && prevChildren[name];\n var nextChild = nextChildren[name];\n if (prevChild === nextChild) {\n this.moveChild(prevChild, nextIndex, lastIndex);\n lastIndex = Math.max(prevChild._mountIndex, lastIndex);\n prevChild._mountIndex = nextIndex;\n } else {\n if (prevChild) {\n // Update `lastIndex` before `_mountIndex` gets unset by unmounting.\n lastIndex = Math.max(prevChild._mountIndex, lastIndex);\n this._unmountChildByName(prevChild, name);\n }\n // The child must be instantiated before it's mounted.\n this._mountChildByNameAtIndex(\n nextChild, name, nextIndex, transaction, context\n );\n }\n nextIndex++;\n }\n // Remove children that are no longer present.\n for (name in prevChildren) {\n if (prevChildren.hasOwnProperty(name) &&\n !(nextChildren && nextChildren.hasOwnProperty(name))) {\n this._unmountChildByName(prevChildren[name], name);\n }\n }\n },\n\n /**\n * Unmounts all rendered children. This should be used to clean up children\n * when this component is unmounted.\n *\n * @internal\n */\n unmountChildren: function() {\n var renderedChildren = this._renderedChildren;\n ReactChildReconciler.unmountChildren(renderedChildren);\n this._renderedChildren = null;\n },\n\n /**\n * Moves a child component to the supplied index.\n *\n * @param {ReactComponent} child Component to move.\n * @param {number} toIndex Destination index of the element.\n * @param {number} lastIndex Last index visited of the siblings of `child`.\n * @protected\n */\n moveChild: function(child, toIndex, lastIndex) {\n // If the index of `child` is less than `lastIndex`, then it needs to\n // be moved. Otherwise, we do not need to move it because a child will be\n // inserted or moved before `child`.\n if (child._mountIndex < lastIndex) {\n enqueueMove(this._rootNodeID, child._mountIndex, toIndex);\n }\n },\n\n /**\n * Creates a child component.\n *\n * @param {ReactComponent} child Component to create.\n * @param {string} mountImage Markup to insert.\n * @protected\n */\n createChild: function(child, mountImage) {\n enqueueMarkup(this._rootNodeID, mountImage, child._mountIndex);\n },\n\n /**\n * Removes a child component.\n *\n * @param {ReactComponent} child Child to remove.\n * @protected\n */\n removeChild: function(child) {\n enqueueRemove(this._rootNodeID, child._mountIndex);\n },\n\n /**\n * Sets this text content string.\n *\n * @param {string} textContent Text content to set.\n * @protected\n */\n setTextContent: function(textContent) {\n enqueueTextContent(this._rootNodeID, textContent);\n },\n\n /**\n * Mounts a child with the supplied name.\n *\n * NOTE: This is part of `updateChildren` and is here for readability.\n *\n * @param {ReactComponent} child Component to mount.\n * @param {string} name Name of the child.\n * @param {number} index Index at which to insert the child.\n * @param {ReactReconcileTransaction} transaction\n * @private\n */\n _mountChildByNameAtIndex: function(\n child,\n name,\n index,\n transaction,\n context) {\n // Inlined for performance, see `ReactInstanceHandles.createReactID`.\n var rootID = this._rootNodeID + name;\n var mountImage = ReactReconciler.mountComponent(\n child,\n rootID,\n transaction,\n context\n );\n child._mountIndex = index;\n this.createChild(child, mountImage);\n },\n\n /**\n * Unmounts a rendered child by name.\n *\n * NOTE: This is part of `updateChildren` and is here for readability.\n *\n * @param {ReactComponent} child Component to unmount.\n * @param {string} name Name of the child in `this._renderedChildren`.\n * @private\n */\n _unmountChildByName: function(child, name) {\n this.removeChild(child);\n child._mountIndex = null;\n }\n\n }\n\n};\n\nmodule.exports = ReactMultiChild;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactMultiChild.js\n ** module id = 148\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ReactMultiChild.js?");
|
||
|
||
/***/ },
|
||
/* 149 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\n * Copyright 2014-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 ReactChildReconciler\n * @typechecks static-only\n */\n\n'use strict';\n\nvar ReactReconciler = __webpack_require__(97);\n\nvar flattenChildren = __webpack_require__(150);\nvar instantiateReactComponent = __webpack_require__(110);\nvar shouldUpdateReactComponent = __webpack_require__(113);\n\n/**\n * ReactChildReconciler provides helpers for initializing or updating a set of\n * children. Its output is suitable for passing it onto ReactMultiChild which\n * does diffed reordering and insertion.\n */\nvar ReactChildReconciler = {\n\n /**\n * Generates a \"mount image\" for each of the supplied children. In the case\n * of `ReactDOMComponent`, a mount image is a string of markup.\n *\n * @param {?object} nestedChildNodes Nested child maps.\n * @return {?object} A set of child instances.\n * @internal\n */\n instantiateChildren: function(nestedChildNodes, transaction, context) {\n var children = flattenChildren(nestedChildNodes);\n for (var name in children) {\n if (children.hasOwnProperty(name)) {\n var child = children[name];\n // The rendered children must be turned into instances as they're\n // mounted.\n var childInstance = instantiateReactComponent(child, null);\n children[name] = childInstance;\n }\n }\n return children;\n },\n\n /**\n * Updates the rendered children and returns a new set of children.\n *\n * @param {?object} prevChildren Previously initialized set of children.\n * @param {?object} nextNestedChildNodes Nested child maps.\n * @param {ReactReconcileTransaction} transaction\n * @param {object} context\n * @return {?object} A new set of child instances.\n * @internal\n */\n updateChildren: function(\n prevChildren,\n nextNestedChildNodes,\n transaction,\n context) {\n // We currently don't have a way to track moves here but if we use iterators\n // instead of for..in we can zip the iterators and check if an item has\n // moved.\n // TODO: If nothing has changed, return the prevChildren object so that we\n // can quickly bailout if nothing has changed.\n var nextChildren = flattenChildren(nextNestedChildNodes);\n if (!nextChildren && !prevChildren) {\n return null;\n }\n var name;\n for (name in nextChildren) {\n if (!nextChildren.hasOwnProperty(name)) {\n continue;\n }\n var prevChild = prevChildren && prevChildren[name];\n var prevElement = prevChild && prevChild._currentElement;\n var nextElement = nextChildren[name];\n if (shouldUpdateReactComponent(prevElement, nextElement)) {\n ReactReconciler.receiveComponent(\n prevChild, nextElement, transaction, context\n );\n nextChildren[name] = prevChild;\n } else {\n if (prevChild) {\n ReactReconciler.unmountComponent(prevChild, name);\n }\n // The child must be instantiated before it's mounted.\n var nextChildInstance = instantiateReactComponent(\n nextElement,\n null\n );\n nextChildren[name] = nextChildInstance;\n }\n }\n // Unmount children that are no longer present.\n for (name in prevChildren) {\n if (prevChildren.hasOwnProperty(name) &&\n !(nextChildren && nextChildren.hasOwnProperty(name))) {\n ReactReconciler.unmountComponent(prevChildren[name]);\n }\n }\n return nextChildren;\n },\n\n /**\n * Unmounts all rendered children. This should be used to clean up children\n * when this component is unmounted.\n *\n * @param {?object} renderedChildren Previously initialized set of children.\n * @internal\n */\n unmountChildren: function(renderedChildren) {\n for (var name in renderedChildren) {\n var renderedChild = renderedChildren[name];\n ReactReconciler.unmountComponent(renderedChild);\n }\n }\n\n};\n\nmodule.exports = ReactChildReconciler;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactChildReconciler.js\n ** module id = 149\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ReactChildReconciler.js?");
|
||
|
||
/***/ },
|
||
/* 150 */
|
||
/***/ 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 flattenChildren\n */\n\n'use strict';\n\nvar traverseAllChildren = __webpack_require__(118);\nvar warning = __webpack_require__(82);\n\n/**\n * @param {function} traverseContext Context passed through traversal.\n * @param {?ReactComponent} child React child component.\n * @param {!string} name String name of key path to child.\n */\nfunction flattenSingleChildIntoContext(traverseContext, child, name) {\n // We found a component instance.\n var result = traverseContext;\n var keyUnique = !result.hasOwnProperty(name);\n if (\"production\" !== process.env.NODE_ENV) {\n (\"production\" !== process.env.NODE_ENV ? warning(\n keyUnique,\n 'flattenChildren(...): Encountered two children with the same key, ' +\n '`%s`. Child keys must be unique; when two children share a key, only ' +\n 'the first child will be used.',\n name\n ) : null);\n }\n if (keyUnique && child != null) {\n result[name] = child;\n }\n}\n\n/**\n * Flattens children that are typically specified as `props.children`. Any null\n * children will not be included in the resulting object.\n * @return {!object} flattened children keyed by name.\n */\nfunction flattenChildren(children) {\n if (children == null) {\n return children;\n }\n var result = {};\n traverseAllChildren(children, flattenSingleChildIntoContext, result);\n return result;\n}\n\nmodule.exports = flattenChildren;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/flattenChildren.js\n ** module id = 150\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/flattenChildren.js?");
|
||
|
||
/***/ },
|
||
/* 151 */
|
||
/***/ 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 ReactDefaultInjection\n */\n\n'use strict';\n\nvar BeforeInputEventPlugin = __webpack_require__(152);\nvar ChangeEventPlugin = __webpack_require__(160);\nvar ClientReactRootIndex = __webpack_require__(162);\nvar DefaultEventPluginOrder = __webpack_require__(163);\nvar EnterLeaveEventPlugin = __webpack_require__(164);\nvar ExecutionEnvironment = __webpack_require__(77);\nvar HTMLDOMPropertyConfig = __webpack_require__(168);\nvar MobileSafariClickEventPlugin = __webpack_require__(169);\nvar ReactBrowserComponentMixin = __webpack_require__(170);\nvar ReactClass = __webpack_require__(120);\nvar ReactComponentBrowserEnvironment =\n __webpack_require__(129);\nvar ReactDefaultBatchingStrategy = __webpack_require__(172);\nvar ReactDOMComponent = __webpack_require__(147);\nvar ReactDOMButton = __webpack_require__(173);\nvar ReactDOMForm = __webpack_require__(176);\nvar ReactDOMImg = __webpack_require__(178);\nvar ReactDOMIDOperations = __webpack_require__(130);\nvar ReactDOMIframe = __webpack_require__(179);\nvar ReactDOMInput = __webpack_require__(180);\nvar ReactDOMOption = __webpack_require__(183);\nvar ReactDOMSelect = __webpack_require__(184);\nvar ReactDOMTextarea = __webpack_require__(185);\nvar ReactDOMTextComponent = __webpack_require__(125);\nvar ReactElement = __webpack_require__(79);\nvar ReactEventListener = __webpack_require__(186);\nvar ReactInjection = __webpack_require__(189);\nvar ReactInstanceHandles = __webpack_require__(92);\nvar ReactMount = __webpack_require__(61);\nvar ReactReconcileTransaction = __webpack_require__(190);\nvar SelectEventPlugin = __webpack_require__(196);\nvar ServerReactRootIndex = __webpack_require__(198);\nvar SimpleEventPlugin = __webpack_require__(199);\nvar SVGDOMPropertyConfig = __webpack_require__(208);\n\nvar createFullPageComponent = __webpack_require__(209);\n\nfunction autoGenerateWrapperClass(type) {\n return ReactClass.createClass({\n tagName: type.toUpperCase(),\n render: function() {\n return new ReactElement(\n type,\n null,\n null,\n null,\n null,\n this.props\n );\n }\n });\n}\n\nfunction inject() {\n ReactInjection.EventEmitter.injectReactEventListener(\n ReactEventListener\n );\n\n /**\n * Inject modules for resolving DOM hierarchy and plugin ordering.\n */\n ReactInjection.EventPluginHub.injectEventPluginOrder(DefaultEventPluginOrder);\n ReactInjection.EventPluginHub.injectInstanceHandle(ReactInstanceHandles);\n ReactInjection.EventPluginHub.injectMount(ReactMount);\n\n /**\n * Some important event plugins included by default (without having to require\n * them).\n */\n ReactInjection.EventPluginHub.injectEventPluginsByName({\n SimpleEventPlugin: SimpleEventPlugin,\n EnterLeaveEventPlugin: EnterLeaveEventPlugin,\n ChangeEventPlugin: ChangeEventPlugin,\n MobileSafariClickEventPlugin: MobileSafariClickEventPlugin,\n SelectEventPlugin: SelectEventPlugin,\n BeforeInputEventPlugin: BeforeInputEventPlugin\n });\n\n ReactInjection.NativeComponent.injectGenericComponentClass(\n ReactDOMComponent\n );\n\n ReactInjection.NativeComponent.injectTextComponentClass(\n ReactDOMTextComponent\n );\n\n ReactInjection.NativeComponent.injectAutoWrapper(\n autoGenerateWrapperClass\n );\n\n // This needs to happen before createFullPageComponent() otherwise the mixin\n // won't be included.\n ReactInjection.Class.injectMixin(ReactBrowserComponentMixin);\n\n ReactInjection.NativeComponent.injectComponentClasses({\n 'button': ReactDOMButton,\n 'form': ReactDOMForm,\n 'iframe': ReactDOMIframe,\n 'img': ReactDOMImg,\n 'input': ReactDOMInput,\n 'option': ReactDOMOption,\n 'select': ReactDOMSelect,\n 'textarea': ReactDOMTextarea,\n\n 'html': createFullPageComponent('html'),\n 'head': createFullPageComponent('head'),\n 'body': createFullPageComponent('body')\n });\n\n ReactInjection.DOMProperty.injectDOMPropertyConfig(HTMLDOMPropertyConfig);\n ReactInjection.DOMProperty.injectDOMPropertyConfig(SVGDOMPropertyConfig);\n\n ReactInjection.EmptyComponent.injectEmptyComponent('noscript');\n\n ReactInjection.Updates.injectReconcileTransaction(\n ReactReconcileTransaction\n );\n ReactInjection.Updates.injectBatchingStrategy(\n ReactDefaultBatchingStrategy\n );\n\n ReactInjection.RootIndex.injectCreateReactRootIndex(\n ExecutionEnvironment.canUseDOM ?\n ClientReactRootIndex.createReactRootIndex :\n ServerReactRootIndex.createReactRootIndex\n );\n\n ReactInjection.Component.injectEnvironment(ReactComponentBrowserEnvironment);\n ReactInjection.DOMComponent.injectIDOperations(ReactDOMIDOperations);\n\n if (\"production\" !== process.env.NODE_ENV) {\n var url = (ExecutionEnvironment.canUseDOM && window.location.href) || '';\n if ((/[?&]react_perf\\b/).test(url)) {\n var ReactDefaultPerf = __webpack_require__(210);\n ReactDefaultPerf.start();\n }\n }\n}\n\nmodule.exports = {\n inject: inject\n};\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactDefaultInjection.js\n ** module id = 151\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ReactDefaultInjection.js?");
|
||
|
||
/***/ },
|
||
/* 152 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\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 BeforeInputEventPlugin\n * @typechecks static-only\n */\n\n'use strict';\n\nvar EventConstants = __webpack_require__(66);\nvar EventPropagators = __webpack_require__(153);\nvar ExecutionEnvironment = __webpack_require__(77);\nvar FallbackCompositionState = __webpack_require__(154);\nvar SyntheticCompositionEvent = __webpack_require__(156);\nvar SyntheticInputEvent = __webpack_require__(159);\n\nvar keyOf = __webpack_require__(122);\n\nvar END_KEYCODES = [9, 13, 27, 32]; // Tab, Return, Esc, Space\nvar START_KEYCODE = 229;\n\nvar canUseCompositionEvent = (\n ExecutionEnvironment.canUseDOM &&\n 'CompositionEvent' in window\n);\n\nvar documentMode = null;\nif (ExecutionEnvironment.canUseDOM && 'documentMode' in document) {\n documentMode = document.documentMode;\n}\n\n// Webkit offers a very useful `textInput` event that can be used to\n// directly represent `beforeInput`. The IE `textinput` event is not as\n// useful, so we don't use it.\nvar canUseTextInputEvent = (\n ExecutionEnvironment.canUseDOM &&\n 'TextEvent' in window &&\n !documentMode &&\n !isPresto()\n);\n\n// In IE9+, we have access to composition events, but the data supplied\n// by the native compositionend event may be incorrect. Japanese ideographic\n// spaces, for instance (\\u3000) are not recorded correctly.\nvar useFallbackCompositionData = (\n ExecutionEnvironment.canUseDOM &&\n (\n (!canUseCompositionEvent || documentMode && documentMode > 8 && documentMode <= 11)\n )\n);\n\n/**\n * Opera <= 12 includes TextEvent in window, but does not fire\n * text input events. Rely on keypress instead.\n */\nfunction isPresto() {\n var opera = window.opera;\n return (\n typeof opera === 'object' &&\n typeof opera.version === 'function' &&\n parseInt(opera.version(), 10) <= 12\n );\n}\n\nvar SPACEBAR_CODE = 32;\nvar SPACEBAR_CHAR = String.fromCharCode(SPACEBAR_CODE);\n\nvar topLevelTypes = EventConstants.topLevelTypes;\n\n// Events and their corresponding property names.\nvar eventTypes = {\n beforeInput: {\n phasedRegistrationNames: {\n bubbled: keyOf({onBeforeInput: null}),\n captured: keyOf({onBeforeInputCapture: null})\n },\n dependencies: [\n topLevelTypes.topCompositionEnd,\n topLevelTypes.topKeyPress,\n topLevelTypes.topTextInput,\n topLevelTypes.topPaste\n ]\n },\n compositionEnd: {\n phasedRegistrationNames: {\n bubbled: keyOf({onCompositionEnd: null}),\n captured: keyOf({onCompositionEndCapture: null})\n },\n dependencies: [\n topLevelTypes.topBlur,\n topLevelTypes.topCompositionEnd,\n topLevelTypes.topKeyDown,\n topLevelTypes.topKeyPress,\n topLevelTypes.topKeyUp,\n topLevelTypes.topMouseDown\n ]\n },\n compositionStart: {\n phasedRegistrationNames: {\n bubbled: keyOf({onCompositionStart: null}),\n captured: keyOf({onCompositionStartCapture: null})\n },\n dependencies: [\n topLevelTypes.topBlur,\n topLevelTypes.topCompositionStart,\n topLevelTypes.topKeyDown,\n topLevelTypes.topKeyPress,\n topLevelTypes.topKeyUp,\n topLevelTypes.topMouseDown\n ]\n },\n compositionUpdate: {\n phasedRegistrationNames: {\n bubbled: keyOf({onCompositionUpdate: null}),\n captured: keyOf({onCompositionUpdateCapture: null})\n },\n dependencies: [\n topLevelTypes.topBlur,\n topLevelTypes.topCompositionUpdate,\n topLevelTypes.topKeyDown,\n topLevelTypes.topKeyPress,\n topLevelTypes.topKeyUp,\n topLevelTypes.topMouseDown\n ]\n }\n};\n\n// Track whether we've ever handled a keypress on the space key.\nvar hasSpaceKeypress = false;\n\n/**\n * Return whether a native keypress event is assumed to be a command.\n * This is required because Firefox fires `keypress` events for key commands\n * (cut, copy, select-all, etc.) even though no character is inserted.\n */\nfunction isKeypressCommand(nativeEvent) {\n return (\n (nativeEvent.ctrlKey || nativeEvent.altKey || nativeEvent.metaKey) &&\n // ctrlKey && altKey is equivalent to AltGr, and is not a command.\n !(nativeEvent.ctrlKey && nativeEvent.altKey)\n );\n}\n\n\n/**\n * Translate native top level events into event types.\n *\n * @param {string} topLevelType\n * @return {object}\n */\nfunction getCompositionEventType(topLevelType) {\n switch (topLevelType) {\n case topLevelTypes.topCompositionStart:\n return eventTypes.compositionStart;\n case topLevelTypes.topCompositionEnd:\n return eventTypes.compositionEnd;\n case topLevelTypes.topCompositionUpdate:\n return eventTypes.compositionUpdate;\n }\n}\n\n/**\n * Does our fallback best-guess model think this event signifies that\n * composition has begun?\n *\n * @param {string} topLevelType\n * @param {object} nativeEvent\n * @return {boolean}\n */\nfunction isFallbackCompositionStart(topLevelType, nativeEvent) {\n return (\n topLevelType === topLevelTypes.topKeyDown &&\n nativeEvent.keyCode === START_KEYCODE\n );\n}\n\n/**\n * Does our fallback mode think that this event is the end of composition?\n *\n * @param {string} topLevelType\n * @param {object} nativeEvent\n * @return {boolean}\n */\nfunction isFallbackCompositionEnd(topLevelType, nativeEvent) {\n switch (topLevelType) {\n case topLevelTypes.topKeyUp:\n // Command keys insert or clear IME input.\n return (END_KEYCODES.indexOf(nativeEvent.keyCode) !== -1);\n case topLevelTypes.topKeyDown:\n // Expect IME keyCode on each keydown. If we get any other\n // code we must have exited earlier.\n return (nativeEvent.keyCode !== START_KEYCODE);\n case topLevelTypes.topKeyPress:\n case topLevelTypes.topMouseDown:\n case topLevelTypes.topBlur:\n // Events are not possible without cancelling IME.\n return true;\n default:\n return false;\n }\n}\n\n/**\n * Google Input Tools provides composition data via a CustomEvent,\n * with the `data` property populated in the `detail` object. If this\n * is available on the event object, use it. If not, this is a plain\n * composition event and we have nothing special to extract.\n *\n * @param {object} nativeEvent\n * @return {?string}\n */\nfunction getDataFromCustomEvent(nativeEvent) {\n var detail = nativeEvent.detail;\n if (typeof detail === 'object' && 'data' in detail) {\n return detail.data;\n }\n return null;\n}\n\n// Track the current IME composition fallback object, if any.\nvar currentComposition = null;\n\n/**\n * @param {string} topLevelType Record from `EventConstants`.\n * @param {DOMEventTarget} topLevelTarget The listening component root node.\n * @param {string} topLevelTargetID ID of `topLevelTarget`.\n * @param {object} nativeEvent Native browser event.\n * @return {?object} A SyntheticCompositionEvent.\n */\nfunction extractCompositionEvent(\n topLevelType,\n topLevelTarget,\n topLevelTargetID,\n nativeEvent\n) {\n var eventType;\n var fallbackData;\n\n if (canUseCompositionEvent) {\n eventType = getCompositionEventType(topLevelType);\n } else if (!currentComposition) {\n if (isFallbackCompositionStart(topLevelType, nativeEvent)) {\n eventType = eventTypes.compositionStart;\n }\n } else if (isFallbackCompositionEnd(topLevelType, nativeEvent)) {\n eventType = eventTypes.compositionEnd;\n }\n\n if (!eventType) {\n return null;\n }\n\n if (useFallbackCompositionData) {\n // The current composition is stored statically and must not be\n // overwritten while composition continues.\n if (!currentComposition && eventType === eventTypes.compositionStart) {\n currentComposition = FallbackCompositionState.getPooled(topLevelTarget);\n } else if (eventType === eventTypes.compositionEnd) {\n if (currentComposition) {\n fallbackData = currentComposition.getData();\n }\n }\n }\n\n var event = SyntheticCompositionEvent.getPooled(\n eventType,\n topLevelTargetID,\n nativeEvent\n );\n\n if (fallbackData) {\n // Inject data generated from fallback path into the synthetic event.\n // This matches the property of native CompositionEventInterface.\n event.data = fallbackData;\n } else {\n var customData = getDataFromCustomEvent(nativeEvent);\n if (customData !== null) {\n event.data = customData;\n }\n }\n\n EventPropagators.accumulateTwoPhaseDispatches(event);\n return event;\n}\n\n/**\n * @param {string} topLevelType Record from `EventConstants`.\n * @param {object} nativeEvent Native browser event.\n * @return {?string} The string corresponding to this `beforeInput` event.\n */\nfunction getNativeBeforeInputChars(topLevelType, nativeEvent) {\n switch (topLevelType) {\n case topLevelTypes.topCompositionEnd:\n return getDataFromCustomEvent(nativeEvent);\n case topLevelTypes.topKeyPress:\n /**\n * If native `textInput` events are available, our goal is to make\n * use of them. However, there is a special case: the spacebar key.\n * In Webkit, preventing default on a spacebar `textInput` event\n * cancels character insertion, but it *also* causes the browser\n * to fall back to its default spacebar behavior of scrolling the\n * page.\n *\n * Tracking at:\n * https://code.google.com/p/chromium/issues/detail?id=355103\n *\n * To avoid this issue, use the keypress event as if no `textInput`\n * event is available.\n */\n var which = nativeEvent.which;\n if (which !== SPACEBAR_CODE) {\n return null;\n }\n\n hasSpaceKeypress = true;\n return SPACEBAR_CHAR;\n\n case topLevelTypes.topTextInput:\n // Record the characters to be added to the DOM.\n var chars = nativeEvent.data;\n\n // If it's a spacebar character, assume that we have already handled\n // it at the keypress level and bail immediately. Android Chrome\n // doesn't give us keycodes, so we need to blacklist it.\n if (chars === SPACEBAR_CHAR && hasSpaceKeypress) {\n return null;\n }\n\n return chars;\n\n default:\n // For other native event types, do nothing.\n return null;\n }\n}\n\n/**\n * For browsers that do not provide the `textInput` event, extract the\n * appropriate string to use for SyntheticInputEvent.\n *\n * @param {string} topLevelType Record from `EventConstants`.\n * @param {object} nativeEvent Native browser event.\n * @return {?string} The fallback string for this `beforeInput` event.\n */\nfunction getFallbackBeforeInputChars(topLevelType, nativeEvent) {\n // If we are currently composing (IME) and using a fallback to do so,\n // try to extract the composed characters from the fallback object.\n if (currentComposition) {\n if (\n topLevelType === topLevelTypes.topCompositionEnd ||\n isFallbackCompositionEnd(topLevelType, nativeEvent)\n ) {\n var chars = currentComposition.getData();\n FallbackCompositionState.release(currentComposition);\n currentComposition = null;\n return chars;\n }\n return null;\n }\n\n switch (topLevelType) {\n case topLevelTypes.topPaste:\n // If a paste event occurs after a keypress, throw out the input\n // chars. Paste events should not lead to BeforeInput events.\n return null;\n case topLevelTypes.topKeyPress:\n /**\n * As of v27, Firefox may fire keypress events even when no character\n * will be inserted. A few possibilities:\n *\n * - `which` is `0`. Arrow keys, Esc key, etc.\n *\n * - `which` is the pressed key code, but no char is available.\n * Ex: 'AltGr + d` in Polish. There is no modified character for\n * this key combination and no character is inserted into the\n * document, but FF fires the keypress for char code `100` anyway.\n * No `input` event will occur.\n *\n * - `which` is the pressed key code, but a command combination is\n * being used. Ex: `Cmd+C`. No character is inserted, and no\n * `input` event will occur.\n */\n if (nativeEvent.which && !isKeypressCommand(nativeEvent)) {\n return String.fromCharCode(nativeEvent.which);\n }\n return null;\n case topLevelTypes.topCompositionEnd:\n return useFallbackCompositionData ? null : nativeEvent.data;\n default:\n return null;\n }\n}\n\n/**\n * Extract a SyntheticInputEvent for `beforeInput`, based on either native\n * `textInput` or fallback behavior.\n *\n * @param {string} topLevelType Record from `EventConstants`.\n * @param {DOMEventTarget} topLevelTarget The listening component root node.\n * @param {string} topLevelTargetID ID of `topLevelTarget`.\n * @param {object} nativeEvent Native browser event.\n * @return {?object} A SyntheticInputEvent.\n */\nfunction extractBeforeInputEvent(\n topLevelType,\n topLevelTarget,\n topLevelTargetID,\n nativeEvent\n) {\n var chars;\n\n if (canUseTextInputEvent) {\n chars = getNativeBeforeInputChars(topLevelType, nativeEvent);\n } else {\n chars = getFallbackBeforeInputChars(topLevelType, nativeEvent);\n }\n\n // If no characters are being inserted, no BeforeInput event should\n // be fired.\n if (!chars) {\n return null;\n }\n\n var event = SyntheticInputEvent.getPooled(\n eventTypes.beforeInput,\n topLevelTargetID,\n nativeEvent\n );\n\n event.data = chars;\n EventPropagators.accumulateTwoPhaseDispatches(event);\n return event;\n}\n\n/**\n * Create an `onBeforeInput` event to match\n * http://www.w3.org/TR/2013/WD-DOM-Level-3-Events-20131105/#events-inputevents.\n *\n * This event plugin is based on the native `textInput` event\n * available in Chrome, Safari, Opera, and IE. This event fires after\n * `onKeyPress` and `onCompositionEnd`, but before `onInput`.\n *\n * `beforeInput` is spec'd but not implemented in any browsers, and\n * the `input` event does not provide any useful information about what has\n * actually been added, contrary to the spec. Thus, `textInput` is the best\n * available event to identify the characters that have actually been inserted\n * into the target node.\n *\n * This plugin is also responsible for emitting `composition` events, thus\n * allowing us to share composition fallback code for both `beforeInput` and\n * `composition` event types.\n */\nvar BeforeInputEventPlugin = {\n\n eventTypes: eventTypes,\n\n /**\n * @param {string} topLevelType Record from `EventConstants`.\n * @param {DOMEventTarget} topLevelTarget The listening component root node.\n * @param {string} topLevelTargetID ID of `topLevelTarget`.\n * @param {object} nativeEvent Native browser event.\n * @return {*} An accumulation of synthetic events.\n * @see {EventPluginHub.extractEvents}\n */\n extractEvents: function(\n topLevelType,\n topLevelTarget,\n topLevelTargetID,\n nativeEvent\n ) {\n return [\n extractCompositionEvent(\n topLevelType,\n topLevelTarget,\n topLevelTargetID,\n nativeEvent\n ),\n extractBeforeInputEvent(\n topLevelType,\n topLevelTarget,\n topLevelTargetID,\n nativeEvent\n )\n ];\n }\n};\n\nmodule.exports = BeforeInputEventPlugin;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/BeforeInputEventPlugin.js\n ** module id = 152\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/BeforeInputEventPlugin.js?");
|
||
|
||
/***/ },
|
||
/* 153 */
|
||
/***/ 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 EventPropagators\n */\n\n'use strict';\n\nvar EventConstants = __webpack_require__(66);\nvar EventPluginHub = __webpack_require__(68);\n\nvar accumulateInto = __webpack_require__(71);\nvar forEachAccumulated = __webpack_require__(72);\n\nvar PropagationPhases = EventConstants.PropagationPhases;\nvar getListener = EventPluginHub.getListener;\n\n/**\n * Some event types have a notion of different registration names for different\n * \"phases\" of propagation. This finds listeners by a given phase.\n */\nfunction listenerAtPhase(id, event, propagationPhase) {\n var registrationName =\n event.dispatchConfig.phasedRegistrationNames[propagationPhase];\n return getListener(id, registrationName);\n}\n\n/**\n * Tags a `SyntheticEvent` with dispatched listeners. Creating this function\n * here, allows us to not have to bind or create functions for each event.\n * Mutating the event's members allows us to not have to create a wrapping\n * \"dispatch\" object that pairs the event with the listener.\n */\nfunction accumulateDirectionalDispatches(domID, upwards, event) {\n if (\"production\" !== process.env.NODE_ENV) {\n if (!domID) {\n throw new Error('Dispatching id must not be null');\n }\n }\n var phase = upwards ? PropagationPhases.bubbled : PropagationPhases.captured;\n var listener = listenerAtPhase(domID, event, phase);\n if (listener) {\n event._dispatchListeners =\n accumulateInto(event._dispatchListeners, listener);\n event._dispatchIDs = accumulateInto(event._dispatchIDs, domID);\n }\n}\n\n/**\n * Collect dispatches (must be entirely collected before dispatching - see unit\n * tests). Lazily allocate the array to conserve memory. We must loop through\n * each event and perform the traversal for each one. We can not perform a\n * single traversal for the entire collection of events because each event may\n * have a different target.\n */\nfunction accumulateTwoPhaseDispatchesSingle(event) {\n if (event && event.dispatchConfig.phasedRegistrationNames) {\n EventPluginHub.injection.getInstanceHandle().traverseTwoPhase(\n event.dispatchMarker,\n accumulateDirectionalDispatches,\n event\n );\n }\n}\n\n\n/**\n * Accumulates without regard to direction, does not look for phased\n * registration names. Same as `accumulateDirectDispatchesSingle` but without\n * requiring that the `dispatchMarker` be the same as the dispatched ID.\n */\nfunction accumulateDispatches(id, ignoredDirection, event) {\n if (event && event.dispatchConfig.registrationName) {\n var registrationName = event.dispatchConfig.registrationName;\n var listener = getListener(id, registrationName);\n if (listener) {\n event._dispatchListeners =\n accumulateInto(event._dispatchListeners, listener);\n event._dispatchIDs = accumulateInto(event._dispatchIDs, id);\n }\n }\n}\n\n/**\n * Accumulates dispatches on an `SyntheticEvent`, but only for the\n * `dispatchMarker`.\n * @param {SyntheticEvent} event\n */\nfunction accumulateDirectDispatchesSingle(event) {\n if (event && event.dispatchConfig.registrationName) {\n accumulateDispatches(event.dispatchMarker, null, event);\n }\n}\n\nfunction accumulateTwoPhaseDispatches(events) {\n forEachAccumulated(events, accumulateTwoPhaseDispatchesSingle);\n}\n\nfunction accumulateEnterLeaveDispatches(leave, enter, fromID, toID) {\n EventPluginHub.injection.getInstanceHandle().traverseEnterLeave(\n fromID,\n toID,\n accumulateDispatches,\n leave,\n enter\n );\n}\n\n\nfunction accumulateDirectDispatches(events) {\n forEachAccumulated(events, accumulateDirectDispatchesSingle);\n}\n\n\n\n/**\n * A small set of propagation patterns, each of which will accept a small amount\n * of information, and generate a set of \"dispatch ready event objects\" - which\n * are sets of events that have already been annotated with a set of dispatched\n * listener functions/ids. The API is designed this way to discourage these\n * propagation strategies from actually executing the dispatches, since we\n * always want to collect the entire set of dispatches before executing event a\n * single one.\n *\n * @constructor EventPropagators\n */\nvar EventPropagators = {\n accumulateTwoPhaseDispatches: accumulateTwoPhaseDispatches,\n accumulateDirectDispatches: accumulateDirectDispatches,\n accumulateEnterLeaveDispatches: accumulateEnterLeaveDispatches\n};\n\nmodule.exports = EventPropagators;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/EventPropagators.js\n ** module id = 153\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/EventPropagators.js?");
|
||
|
||
/***/ },
|
||
/* 154 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\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 FallbackCompositionState\n * @typechecks static-only\n */\n\n'use strict';\n\nvar PooledClass = __webpack_require__(103);\n\nvar assign = __webpack_require__(75);\nvar getTextContentAccessor = __webpack_require__(155);\n\n/**\n * This helper class stores information about text content of a target node,\n * allowing comparison of content before and after a given event.\n *\n * Identify the node where selection currently begins, then observe\n * both its text content and its current position in the DOM. Since the\n * browser may natively replace the target node during composition, we can\n * use its position to find its replacement.\n *\n * @param {DOMEventTarget} root\n */\nfunction FallbackCompositionState(root) {\n this._root = root;\n this._startText = this.getText();\n this._fallbackText = null;\n}\n\nassign(FallbackCompositionState.prototype, {\n /**\n * Get current text of input.\n *\n * @return {string}\n */\n getText: function() {\n if ('value' in this._root) {\n return this._root.value;\n }\n return this._root[getTextContentAccessor()];\n },\n\n /**\n * Determine the differing substring between the initially stored\n * text content and the current content.\n *\n * @return {string}\n */\n getData: function() {\n if (this._fallbackText) {\n return this._fallbackText;\n }\n\n var start;\n var startValue = this._startText;\n var startLength = startValue.length;\n var end;\n var endValue = this.getText();\n var endLength = endValue.length;\n\n for (start = 0; start < startLength; start++) {\n if (startValue[start] !== endValue[start]) {\n break;\n }\n }\n\n var minEnd = startLength - start;\n for (end = 1; end <= minEnd; end++) {\n if (startValue[startLength - end] !== endValue[endLength - end]) {\n break;\n }\n }\n\n var sliceTail = end > 1 ? 1 - end : undefined;\n this._fallbackText = endValue.slice(start, sliceTail);\n return this._fallbackText;\n }\n});\n\nPooledClass.addPoolingTo(FallbackCompositionState);\n\nmodule.exports = FallbackCompositionState;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/FallbackCompositionState.js\n ** module id = 154\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/FallbackCompositionState.js?");
|
||
|
||
/***/ },
|
||
/* 155 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\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 getTextContentAccessor\n */\n\n'use strict';\n\nvar ExecutionEnvironment = __webpack_require__(77);\n\nvar contentKey = null;\n\n/**\n * Gets the key used to access text content on a DOM node.\n *\n * @return {?string} Key used to access text content.\n * @internal\n */\nfunction getTextContentAccessor() {\n if (!contentKey && ExecutionEnvironment.canUseDOM) {\n // Prefer textContent to innerText because many browsers support both but\n // SVG <text> elements don't support innerText even when <div> does.\n contentKey = 'textContent' in document.documentElement ?\n 'textContent' :\n 'innerText';\n }\n return contentKey;\n}\n\nmodule.exports = getTextContentAccessor;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/getTextContentAccessor.js\n ** module id = 155\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/getTextContentAccessor.js?");
|
||
|
||
/***/ },
|
||
/* 156 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\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 SyntheticCompositionEvent\n * @typechecks static-only\n */\n\n'use strict';\n\nvar SyntheticEvent = __webpack_require__(157);\n\n/**\n * @interface Event\n * @see http://www.w3.org/TR/DOM-Level-3-Events/#events-compositionevents\n */\nvar CompositionEventInterface = {\n data: null\n};\n\n/**\n * @param {object} dispatchConfig Configuration used to dispatch this event.\n * @param {string} dispatchMarker Marker identifying the event target.\n * @param {object} nativeEvent Native browser event.\n * @extends {SyntheticUIEvent}\n */\nfunction SyntheticCompositionEvent(\n dispatchConfig,\n dispatchMarker,\n nativeEvent) {\n SyntheticEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent);\n}\n\nSyntheticEvent.augmentClass(\n SyntheticCompositionEvent,\n CompositionEventInterface\n);\n\nmodule.exports = SyntheticCompositionEvent;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/SyntheticCompositionEvent.js\n ** module id = 156\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/SyntheticCompositionEvent.js?");
|
||
|
||
/***/ },
|
||
/* 157 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\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 SyntheticEvent\n * @typechecks static-only\n */\n\n'use strict';\n\nvar PooledClass = __webpack_require__(103);\n\nvar assign = __webpack_require__(75);\nvar emptyFunction = __webpack_require__(83);\nvar getEventTarget = __webpack_require__(158);\n\n/**\n * @interface Event\n * @see http://www.w3.org/TR/DOM-Level-3-Events/\n */\nvar EventInterface = {\n type: null,\n target: getEventTarget,\n // currentTarget is set when dispatching; no use in copying it here\n currentTarget: emptyFunction.thatReturnsNull,\n eventPhase: null,\n bubbles: null,\n cancelable: null,\n timeStamp: function(event) {\n return event.timeStamp || Date.now();\n },\n defaultPrevented: null,\n isTrusted: null\n};\n\n/**\n * Synthetic events are dispatched by event plugins, typically in response to a\n * top-level event delegation handler.\n *\n * These systems should generally use pooling to reduce the frequency of garbage\n * collection. The system should check `isPersistent` to determine whether the\n * event should be released into the pool after being dispatched. Users that\n * need a persisted event should invoke `persist`.\n *\n * Synthetic events (and subclasses) implement the DOM Level 3 Events API by\n * normalizing browser quirks. Subclasses do not necessarily have to implement a\n * DOM interface; custom application-specific events can also subclass this.\n *\n * @param {object} dispatchConfig Configuration used to dispatch this event.\n * @param {string} dispatchMarker Marker identifying the event target.\n * @param {object} nativeEvent Native browser event.\n */\nfunction SyntheticEvent(dispatchConfig, dispatchMarker, nativeEvent) {\n this.dispatchConfig = dispatchConfig;\n this.dispatchMarker = dispatchMarker;\n this.nativeEvent = nativeEvent;\n\n var Interface = this.constructor.Interface;\n for (var propName in Interface) {\n if (!Interface.hasOwnProperty(propName)) {\n continue;\n }\n var normalize = Interface[propName];\n if (normalize) {\n this[propName] = normalize(nativeEvent);\n } else {\n this[propName] = nativeEvent[propName];\n }\n }\n\n var defaultPrevented = nativeEvent.defaultPrevented != null ?\n nativeEvent.defaultPrevented :\n nativeEvent.returnValue === false;\n if (defaultPrevented) {\n this.isDefaultPrevented = emptyFunction.thatReturnsTrue;\n } else {\n this.isDefaultPrevented = emptyFunction.thatReturnsFalse;\n }\n this.isPropagationStopped = emptyFunction.thatReturnsFalse;\n}\n\nassign(SyntheticEvent.prototype, {\n\n preventDefault: function() {\n this.defaultPrevented = true;\n var event = this.nativeEvent;\n if (event.preventDefault) {\n event.preventDefault();\n } else {\n event.returnValue = false;\n }\n this.isDefaultPrevented = emptyFunction.thatReturnsTrue;\n },\n\n stopPropagation: function() {\n var event = this.nativeEvent;\n if (event.stopPropagation) {\n event.stopPropagation();\n } else {\n event.cancelBubble = true;\n }\n this.isPropagationStopped = emptyFunction.thatReturnsTrue;\n },\n\n /**\n * We release all dispatched `SyntheticEvent`s after each event loop, adding\n * them back into the pool. This allows a way to hold onto a reference that\n * won't be added back into the pool.\n */\n persist: function() {\n this.isPersistent = emptyFunction.thatReturnsTrue;\n },\n\n /**\n * Checks if this event should be released back into the pool.\n *\n * @return {boolean} True if this should not be released, false otherwise.\n */\n isPersistent: emptyFunction.thatReturnsFalse,\n\n /**\n * `PooledClass` looks for `destructor` on each instance it releases.\n */\n destructor: function() {\n var Interface = this.constructor.Interface;\n for (var propName in Interface) {\n this[propName] = null;\n }\n this.dispatchConfig = null;\n this.dispatchMarker = null;\n this.nativeEvent = null;\n }\n\n});\n\nSyntheticEvent.Interface = EventInterface;\n\n/**\n * Helper to reduce boilerplate when creating subclasses.\n *\n * @param {function} Class\n * @param {?object} Interface\n */\nSyntheticEvent.augmentClass = function(Class, Interface) {\n var Super = this;\n\n var prototype = Object.create(Super.prototype);\n assign(prototype, Class.prototype);\n Class.prototype = prototype;\n Class.prototype.constructor = Class;\n\n Class.Interface = assign({}, Super.Interface, Interface);\n Class.augmentClass = Super.augmentClass;\n\n PooledClass.addPoolingTo(Class, PooledClass.threeArgumentPooler);\n};\n\nPooledClass.addPoolingTo(SyntheticEvent, PooledClass.threeArgumentPooler);\n\nmodule.exports = SyntheticEvent;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/SyntheticEvent.js\n ** module id = 157\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/SyntheticEvent.js?");
|
||
|
||
/***/ },
|
||
/* 158 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("/**\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 getEventTarget\n * @typechecks static-only\n */\n\n'use strict';\n\n/**\n * Gets the target node from a native browser event by accounting for\n * inconsistencies in browser DOM APIs.\n *\n * @param {object} nativeEvent Native browser event.\n * @return {DOMEventTarget} Target node.\n */\nfunction getEventTarget(nativeEvent) {\n var target = nativeEvent.target || nativeEvent.srcElement || window;\n // Safari may fire events on text nodes (Node.TEXT_NODE is 3).\n // @see http://www.quirksmode.org/js/events_properties.html\n return target.nodeType === 3 ? target.parentNode : target;\n}\n\nmodule.exports = getEventTarget;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/getEventTarget.js\n ** module id = 158\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/getEventTarget.js?");
|
||
|
||
/***/ },
|
||
/* 159 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\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 SyntheticInputEvent\n * @typechecks static-only\n */\n\n'use strict';\n\nvar SyntheticEvent = __webpack_require__(157);\n\n/**\n * @interface Event\n * @see http://www.w3.org/TR/2013/WD-DOM-Level-3-Events-20131105\n * /#events-inputevents\n */\nvar InputEventInterface = {\n data: null\n};\n\n/**\n * @param {object} dispatchConfig Configuration used to dispatch this event.\n * @param {string} dispatchMarker Marker identifying the event target.\n * @param {object} nativeEvent Native browser event.\n * @extends {SyntheticUIEvent}\n */\nfunction SyntheticInputEvent(\n dispatchConfig,\n dispatchMarker,\n nativeEvent) {\n SyntheticEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent);\n}\n\nSyntheticEvent.augmentClass(\n SyntheticInputEvent,\n InputEventInterface\n);\n\nmodule.exports = SyntheticInputEvent;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/SyntheticInputEvent.js\n ** module id = 159\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/SyntheticInputEvent.js?");
|
||
|
||
/***/ },
|
||
/* 160 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\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 ChangeEventPlugin\n */\n\n'use strict';\n\nvar EventConstants = __webpack_require__(66);\nvar EventPluginHub = __webpack_require__(68);\nvar EventPropagators = __webpack_require__(153);\nvar ExecutionEnvironment = __webpack_require__(77);\nvar ReactUpdates = __webpack_require__(101);\nvar SyntheticEvent = __webpack_require__(157);\n\nvar isEventSupported = __webpack_require__(76);\nvar isTextInputElement = __webpack_require__(161);\nvar keyOf = __webpack_require__(122);\n\nvar topLevelTypes = EventConstants.topLevelTypes;\n\nvar eventTypes = {\n change: {\n phasedRegistrationNames: {\n bubbled: keyOf({onChange: null}),\n captured: keyOf({onChangeCapture: null})\n },\n dependencies: [\n topLevelTypes.topBlur,\n topLevelTypes.topChange,\n topLevelTypes.topClick,\n topLevelTypes.topFocus,\n topLevelTypes.topInput,\n topLevelTypes.topKeyDown,\n topLevelTypes.topKeyUp,\n topLevelTypes.topSelectionChange\n ]\n }\n};\n\n/**\n * For IE shims\n */\nvar activeElement = null;\nvar activeElementID = null;\nvar activeElementValue = null;\nvar activeElementValueProp = null;\n\n/**\n * SECTION: handle `change` event\n */\nfunction shouldUseChangeEvent(elem) {\n return (\n elem.nodeName === 'SELECT' ||\n (elem.nodeName === 'INPUT' && elem.type === 'file')\n );\n}\n\nvar doesChangeEventBubble = false;\nif (ExecutionEnvironment.canUseDOM) {\n // See `handleChange` comment below\n doesChangeEventBubble = isEventSupported('change') && (\n (!('documentMode' in document) || document.documentMode > 8)\n );\n}\n\nfunction manualDispatchChangeEvent(nativeEvent) {\n var event = SyntheticEvent.getPooled(\n eventTypes.change,\n activeElementID,\n nativeEvent\n );\n EventPropagators.accumulateTwoPhaseDispatches(event);\n\n // If change and propertychange bubbled, we'd just bind to it like all the\n // other events and have it go through ReactBrowserEventEmitter. Since it\n // doesn't, we manually listen for the events and so we have to enqueue and\n // process the abstract event manually.\n //\n // Batching is necessary here in order to ensure that all event handlers run\n // before the next rerender (including event handlers attached to ancestor\n // elements instead of directly on the input). Without this, controlled\n // components don't work properly in conjunction with event bubbling because\n // the component is rerendered and the value reverted before all the event\n // handlers can run. See https://github.com/facebook/react/issues/708.\n ReactUpdates.batchedUpdates(runEventInBatch, event);\n}\n\nfunction runEventInBatch(event) {\n EventPluginHub.enqueueEvents(event);\n EventPluginHub.processEventQueue();\n}\n\nfunction startWatchingForChangeEventIE8(target, targetID) {\n activeElement = target;\n activeElementID = targetID;\n activeElement.attachEvent('onchange', manualDispatchChangeEvent);\n}\n\nfunction stopWatchingForChangeEventIE8() {\n if (!activeElement) {\n return;\n }\n activeElement.detachEvent('onchange', manualDispatchChangeEvent);\n activeElement = null;\n activeElementID = null;\n}\n\nfunction getTargetIDForChangeEvent(\n topLevelType,\n topLevelTarget,\n topLevelTargetID) {\n if (topLevelType === topLevelTypes.topChange) {\n return topLevelTargetID;\n }\n}\nfunction handleEventsForChangeEventIE8(\n topLevelType,\n topLevelTarget,\n topLevelTargetID) {\n if (topLevelType === topLevelTypes.topFocus) {\n // stopWatching() should be a noop here but we call it just in case we\n // missed a blur event somehow.\n stopWatchingForChangeEventIE8();\n startWatchingForChangeEventIE8(topLevelTarget, topLevelTargetID);\n } else if (topLevelType === topLevelTypes.topBlur) {\n stopWatchingForChangeEventIE8();\n }\n}\n\n\n/**\n * SECTION: handle `input` event\n */\nvar isInputEventSupported = false;\nif (ExecutionEnvironment.canUseDOM) {\n // IE9 claims to support the input event but fails to trigger it when\n // deleting text, so we ignore its input events\n isInputEventSupported = isEventSupported('input') && (\n (!('documentMode' in document) || document.documentMode > 9)\n );\n}\n\n/**\n * (For old IE.) Replacement getter/setter for the `value` property that gets\n * set on the active element.\n */\nvar newValueProp = {\n get: function() {\n return activeElementValueProp.get.call(this);\n },\n set: function(val) {\n // Cast to a string so we can do equality checks.\n activeElementValue = '' + val;\n activeElementValueProp.set.call(this, val);\n }\n};\n\n/**\n * (For old IE.) Starts tracking propertychange events on the passed-in element\n * and override the value property so that we can distinguish user events from\n * value changes in JS.\n */\nfunction startWatchingForValueChange(target, targetID) {\n activeElement = target;\n activeElementID = targetID;\n activeElementValue = target.value;\n activeElementValueProp = Object.getOwnPropertyDescriptor(\n target.constructor.prototype,\n 'value'\n );\n\n Object.defineProperty(activeElement, 'value', newValueProp);\n activeElement.attachEvent('onpropertychange', handlePropertyChange);\n}\n\n/**\n * (For old IE.) Removes the event listeners from the currently-tracked element,\n * if any exists.\n */\nfunction stopWatchingForValueChange() {\n if (!activeElement) {\n return;\n }\n\n // delete restores the original property definition\n delete activeElement.value;\n activeElement.detachEvent('onpropertychange', handlePropertyChange);\n\n activeElement = null;\n activeElementID = null;\n activeElementValue = null;\n activeElementValueProp = null;\n}\n\n/**\n * (For old IE.) Handles a propertychange event, sending a `change` event if\n * the value of the active element has changed.\n */\nfunction handlePropertyChange(nativeEvent) {\n if (nativeEvent.propertyName !== 'value') {\n return;\n }\n var value = nativeEvent.srcElement.value;\n if (value === activeElementValue) {\n return;\n }\n activeElementValue = value;\n\n manualDispatchChangeEvent(nativeEvent);\n}\n\n/**\n * If a `change` event should be fired, returns the target's ID.\n */\nfunction getTargetIDForInputEvent(\n topLevelType,\n topLevelTarget,\n topLevelTargetID) {\n if (topLevelType === topLevelTypes.topInput) {\n // In modern browsers (i.e., not IE8 or IE9), the input event is exactly\n // what we want so fall through here and trigger an abstract event\n return topLevelTargetID;\n }\n}\n\n// For IE8 and IE9.\nfunction handleEventsForInputEventIE(\n topLevelType,\n topLevelTarget,\n topLevelTargetID) {\n if (topLevelType === topLevelTypes.topFocus) {\n // In IE8, we can capture almost all .value changes by adding a\n // propertychange handler and looking for events with propertyName\n // equal to 'value'\n // In IE9, propertychange fires for most input events but is buggy and\n // doesn't fire when text is deleted, but conveniently, selectionchange\n // appears to fire in all of the remaining cases so we catch those and\n // forward the event if the value has changed\n // In either case, we don't want to call the event handler if the value\n // is changed from JS so we redefine a setter for `.value` that updates\n // our activeElementValue variable, allowing us to ignore those changes\n //\n // stopWatching() should be a noop here but we call it just in case we\n // missed a blur event somehow.\n stopWatchingForValueChange();\n startWatchingForValueChange(topLevelTarget, topLevelTargetID);\n } else if (topLevelType === topLevelTypes.topBlur) {\n stopWatchingForValueChange();\n }\n}\n\n// For IE8 and IE9.\nfunction getTargetIDForInputEventIE(\n topLevelType,\n topLevelTarget,\n topLevelTargetID) {\n if (topLevelType === topLevelTypes.topSelectionChange ||\n topLevelType === topLevelTypes.topKeyUp ||\n topLevelType === topLevelTypes.topKeyDown) {\n // On the selectionchange event, the target is just document which isn't\n // helpful for us so just check activeElement instead.\n //\n // 99% of the time, keydown and keyup aren't necessary. IE8 fails to fire\n // propertychange on the first input event after setting `value` from a\n // script and fires only keydown, keypress, keyup. Catching keyup usually\n // gets it and catching keydown lets us fire an event for the first\n // keystroke if user does a key repeat (it'll be a little delayed: right\n // before the second keystroke). Other input methods (e.g., paste) seem to\n // fire selectionchange normally.\n if (activeElement && activeElement.value !== activeElementValue) {\n activeElementValue = activeElement.value;\n return activeElementID;\n }\n }\n}\n\n\n/**\n * SECTION: handle `click` event\n */\nfunction shouldUseClickEvent(elem) {\n // Use the `click` event to detect changes to checkbox and radio inputs.\n // This approach works across all browsers, whereas `change` does not fire\n // until `blur` in IE8.\n return (\n elem.nodeName === 'INPUT' &&\n (elem.type === 'checkbox' || elem.type === 'radio')\n );\n}\n\nfunction getTargetIDForClickEvent(\n topLevelType,\n topLevelTarget,\n topLevelTargetID) {\n if (topLevelType === topLevelTypes.topClick) {\n return topLevelTargetID;\n }\n}\n\n/**\n * This plugin creates an `onChange` event that normalizes change events\n * across form elements. This event fires at a time when it's possible to\n * change the element's value without seeing a flicker.\n *\n * Supported elements are:\n * - input (see `isTextInputElement`)\n * - textarea\n * - select\n */\nvar ChangeEventPlugin = {\n\n eventTypes: eventTypes,\n\n /**\n * @param {string} topLevelType Record from `EventConstants`.\n * @param {DOMEventTarget} topLevelTarget The listening component root node.\n * @param {string} topLevelTargetID ID of `topLevelTarget`.\n * @param {object} nativeEvent Native browser event.\n * @return {*} An accumulation of synthetic events.\n * @see {EventPluginHub.extractEvents}\n */\n extractEvents: function(\n topLevelType,\n topLevelTarget,\n topLevelTargetID,\n nativeEvent) {\n\n var getTargetIDFunc, handleEventFunc;\n if (shouldUseChangeEvent(topLevelTarget)) {\n if (doesChangeEventBubble) {\n getTargetIDFunc = getTargetIDForChangeEvent;\n } else {\n handleEventFunc = handleEventsForChangeEventIE8;\n }\n } else if (isTextInputElement(topLevelTarget)) {\n if (isInputEventSupported) {\n getTargetIDFunc = getTargetIDForInputEvent;\n } else {\n getTargetIDFunc = getTargetIDForInputEventIE;\n handleEventFunc = handleEventsForInputEventIE;\n }\n } else if (shouldUseClickEvent(topLevelTarget)) {\n getTargetIDFunc = getTargetIDForClickEvent;\n }\n\n if (getTargetIDFunc) {\n var targetID = getTargetIDFunc(\n topLevelType,\n topLevelTarget,\n topLevelTargetID\n );\n if (targetID) {\n var event = SyntheticEvent.getPooled(\n eventTypes.change,\n targetID,\n nativeEvent\n );\n EventPropagators.accumulateTwoPhaseDispatches(event);\n return event;\n }\n }\n\n if (handleEventFunc) {\n handleEventFunc(\n topLevelType,\n topLevelTarget,\n topLevelTargetID\n );\n }\n }\n\n};\n\nmodule.exports = ChangeEventPlugin;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ChangeEventPlugin.js\n ** module id = 160\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ChangeEventPlugin.js?");
|
||
|
||
/***/ },
|
||
/* 161 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("/**\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 isTextInputElement\n */\n\n'use strict';\n\n/**\n * @see http://www.whatwg.org/specs/web-apps/current-work/multipage/the-input-element.html#input-type-attr-summary\n */\nvar supportedInputTypes = {\n 'color': true,\n 'date': true,\n 'datetime': true,\n 'datetime-local': true,\n 'email': true,\n 'month': true,\n 'number': true,\n 'password': true,\n 'range': true,\n 'search': true,\n 'tel': true,\n 'text': true,\n 'time': true,\n 'url': true,\n 'week': true\n};\n\nfunction isTextInputElement(elem) {\n return elem && (\n (elem.nodeName === 'INPUT' && supportedInputTypes[elem.type] || elem.nodeName === 'TEXTAREA')\n );\n}\n\nmodule.exports = isTextInputElement;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/isTextInputElement.js\n ** module id = 161\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/isTextInputElement.js?");
|
||
|
||
/***/ },
|
||
/* 162 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("/**\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 ClientReactRootIndex\n * @typechecks\n */\n\n'use strict';\n\nvar nextReactRootIndex = 0;\n\nvar ClientReactRootIndex = {\n createReactRootIndex: function() {\n return nextReactRootIndex++;\n }\n};\n\nmodule.exports = ClientReactRootIndex;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ClientReactRootIndex.js\n ** module id = 162\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ClientReactRootIndex.js?");
|
||
|
||
/***/ },
|
||
/* 163 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\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 DefaultEventPluginOrder\n */\n\n'use strict';\n\nvar keyOf = __webpack_require__(122);\n\n/**\n * Module that is injectable into `EventPluginHub`, that specifies a\n * deterministic ordering of `EventPlugin`s. A convenient way to reason about\n * plugins, without having to package every one of them. This is better than\n * having plugins be ordered in the same order that they are injected because\n * that ordering would be influenced by the packaging order.\n * `ResponderEventPlugin` must occur before `SimpleEventPlugin` so that\n * preventing default on events is convenient in `SimpleEventPlugin` handlers.\n */\nvar DefaultEventPluginOrder = [\n keyOf({ResponderEventPlugin: null}),\n keyOf({SimpleEventPlugin: null}),\n keyOf({TapEventPlugin: null}),\n keyOf({EnterLeaveEventPlugin: null}),\n keyOf({ChangeEventPlugin: null}),\n keyOf({SelectEventPlugin: null}),\n keyOf({BeforeInputEventPlugin: null}),\n keyOf({AnalyticsEventPlugin: null}),\n keyOf({MobileSafariClickEventPlugin: null})\n];\n\nmodule.exports = DefaultEventPluginOrder;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/DefaultEventPluginOrder.js\n ** module id = 163\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/DefaultEventPluginOrder.js?");
|
||
|
||
/***/ },
|
||
/* 164 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\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 EnterLeaveEventPlugin\n * @typechecks static-only\n */\n\n'use strict';\n\nvar EventConstants = __webpack_require__(66);\nvar EventPropagators = __webpack_require__(153);\nvar SyntheticMouseEvent = __webpack_require__(165);\n\nvar ReactMount = __webpack_require__(61);\nvar keyOf = __webpack_require__(122);\n\nvar topLevelTypes = EventConstants.topLevelTypes;\nvar getFirstReactDOM = ReactMount.getFirstReactDOM;\n\nvar eventTypes = {\n mouseEnter: {\n registrationName: keyOf({onMouseEnter: null}),\n dependencies: [\n topLevelTypes.topMouseOut,\n topLevelTypes.topMouseOver\n ]\n },\n mouseLeave: {\n registrationName: keyOf({onMouseLeave: null}),\n dependencies: [\n topLevelTypes.topMouseOut,\n topLevelTypes.topMouseOver\n ]\n }\n};\n\nvar extractedEvents = [null, null];\n\nvar EnterLeaveEventPlugin = {\n\n eventTypes: eventTypes,\n\n /**\n * For almost every interaction we care about, there will be both a top-level\n * `mouseover` and `mouseout` event that occurs. Only use `mouseout` so that\n * we do not extract duplicate events. However, moving the mouse into the\n * browser from outside will not fire a `mouseout` event. In this case, we use\n * the `mouseover` top-level event.\n *\n * @param {string} topLevelType Record from `EventConstants`.\n * @param {DOMEventTarget} topLevelTarget The listening component root node.\n * @param {string} topLevelTargetID ID of `topLevelTarget`.\n * @param {object} nativeEvent Native browser event.\n * @return {*} An accumulation of synthetic events.\n * @see {EventPluginHub.extractEvents}\n */\n extractEvents: function(\n topLevelType,\n topLevelTarget,\n topLevelTargetID,\n nativeEvent) {\n if (topLevelType === topLevelTypes.topMouseOver &&\n (nativeEvent.relatedTarget || nativeEvent.fromElement)) {\n return null;\n }\n if (topLevelType !== topLevelTypes.topMouseOut &&\n topLevelType !== topLevelTypes.topMouseOver) {\n // Must not be a mouse in or mouse out - ignoring.\n return null;\n }\n\n var win;\n if (topLevelTarget.window === topLevelTarget) {\n // `topLevelTarget` is probably a window object.\n win = topLevelTarget;\n } else {\n // TODO: Figure out why `ownerDocument` is sometimes undefined in IE8.\n var doc = topLevelTarget.ownerDocument;\n if (doc) {\n win = doc.defaultView || doc.parentWindow;\n } else {\n win = window;\n }\n }\n\n var from, to;\n if (topLevelType === topLevelTypes.topMouseOut) {\n from = topLevelTarget;\n to =\n getFirstReactDOM(nativeEvent.relatedTarget || nativeEvent.toElement) ||\n win;\n } else {\n from = win;\n to = topLevelTarget;\n }\n\n if (from === to) {\n // Nothing pertains to our managed components.\n return null;\n }\n\n var fromID = from ? ReactMount.getID(from) : '';\n var toID = to ? ReactMount.getID(to) : '';\n\n var leave = SyntheticMouseEvent.getPooled(\n eventTypes.mouseLeave,\n fromID,\n nativeEvent\n );\n leave.type = 'mouseleave';\n leave.target = from;\n leave.relatedTarget = to;\n\n var enter = SyntheticMouseEvent.getPooled(\n eventTypes.mouseEnter,\n toID,\n nativeEvent\n );\n enter.type = 'mouseenter';\n enter.target = to;\n enter.relatedTarget = from;\n\n EventPropagators.accumulateEnterLeaveDispatches(leave, enter, fromID, toID);\n\n extractedEvents[0] = leave;\n extractedEvents[1] = enter;\n\n return extractedEvents;\n }\n\n};\n\nmodule.exports = EnterLeaveEventPlugin;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/EnterLeaveEventPlugin.js\n ** module id = 164\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/EnterLeaveEventPlugin.js?");
|
||
|
||
/***/ },
|
||
/* 165 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\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 SyntheticMouseEvent\n * @typechecks static-only\n */\n\n'use strict';\n\nvar SyntheticUIEvent = __webpack_require__(166);\nvar ViewportMetrics = __webpack_require__(74);\n\nvar getEventModifierState = __webpack_require__(167);\n\n/**\n * @interface MouseEvent\n * @see http://www.w3.org/TR/DOM-Level-3-Events/\n */\nvar MouseEventInterface = {\n screenX: null,\n screenY: null,\n clientX: null,\n clientY: null,\n ctrlKey: null,\n shiftKey: null,\n altKey: null,\n metaKey: null,\n getModifierState: getEventModifierState,\n button: function(event) {\n // Webkit, Firefox, IE9+\n // which: 1 2 3\n // button: 0 1 2 (standard)\n var button = event.button;\n if ('which' in event) {\n return button;\n }\n // IE<9\n // which: undefined\n // button: 0 0 0\n // button: 1 4 2 (onmouseup)\n return button === 2 ? 2 : button === 4 ? 1 : 0;\n },\n buttons: null,\n relatedTarget: function(event) {\n return event.relatedTarget || (\n ((event.fromElement === event.srcElement ? event.toElement : event.fromElement))\n );\n },\n // \"Proprietary\" Interface.\n pageX: function(event) {\n return 'pageX' in event ?\n event.pageX :\n event.clientX + ViewportMetrics.currentScrollLeft;\n },\n pageY: function(event) {\n return 'pageY' in event ?\n event.pageY :\n event.clientY + ViewportMetrics.currentScrollTop;\n }\n};\n\n/**\n * @param {object} dispatchConfig Configuration used to dispatch this event.\n * @param {string} dispatchMarker Marker identifying the event target.\n * @param {object} nativeEvent Native browser event.\n * @extends {SyntheticUIEvent}\n */\nfunction SyntheticMouseEvent(dispatchConfig, dispatchMarker, nativeEvent) {\n SyntheticUIEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent);\n}\n\nSyntheticUIEvent.augmentClass(SyntheticMouseEvent, MouseEventInterface);\n\nmodule.exports = SyntheticMouseEvent;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/SyntheticMouseEvent.js\n ** module id = 165\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/SyntheticMouseEvent.js?");
|
||
|
||
/***/ },
|
||
/* 166 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\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 SyntheticUIEvent\n * @typechecks static-only\n */\n\n'use strict';\n\nvar SyntheticEvent = __webpack_require__(157);\n\nvar getEventTarget = __webpack_require__(158);\n\n/**\n * @interface UIEvent\n * @see http://www.w3.org/TR/DOM-Level-3-Events/\n */\nvar UIEventInterface = {\n view: function(event) {\n if (event.view) {\n return event.view;\n }\n\n var target = getEventTarget(event);\n if (target != null && target.window === target) {\n // target is a window object\n return target;\n }\n\n var doc = target.ownerDocument;\n // TODO: Figure out why `ownerDocument` is sometimes undefined in IE8.\n if (doc) {\n return doc.defaultView || doc.parentWindow;\n } else {\n return window;\n }\n },\n detail: function(event) {\n return event.detail || 0;\n }\n};\n\n/**\n * @param {object} dispatchConfig Configuration used to dispatch this event.\n * @param {string} dispatchMarker Marker identifying the event target.\n * @param {object} nativeEvent Native browser event.\n * @extends {SyntheticEvent}\n */\nfunction SyntheticUIEvent(dispatchConfig, dispatchMarker, nativeEvent) {\n SyntheticEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent);\n}\n\nSyntheticEvent.augmentClass(SyntheticUIEvent, UIEventInterface);\n\nmodule.exports = SyntheticUIEvent;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/SyntheticUIEvent.js\n ** module id = 166\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/SyntheticUIEvent.js?");
|
||
|
||
/***/ },
|
||
/* 167 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("/**\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 getEventModifierState\n * @typechecks static-only\n */\n\n'use strict';\n\n/**\n * Translation from modifier key to the associated property in the event.\n * @see http://www.w3.org/TR/DOM-Level-3-Events/#keys-Modifiers\n */\n\nvar modifierKeyToProp = {\n 'Alt': 'altKey',\n 'Control': 'ctrlKey',\n 'Meta': 'metaKey',\n 'Shift': 'shiftKey'\n};\n\n// IE8 does not implement getModifierState so we simply map it to the only\n// modifier keys exposed by the event itself, does not support Lock-keys.\n// Currently, all major browsers except Chrome seems to support Lock-keys.\nfunction modifierStateGetter(keyArg) {\n /*jshint validthis:true */\n var syntheticEvent = this;\n var nativeEvent = syntheticEvent.nativeEvent;\n if (nativeEvent.getModifierState) {\n return nativeEvent.getModifierState(keyArg);\n }\n var keyProp = modifierKeyToProp[keyArg];\n return keyProp ? !!nativeEvent[keyProp] : false;\n}\n\nfunction getEventModifierState(nativeEvent) {\n return modifierStateGetter;\n}\n\nmodule.exports = getEventModifierState;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/getEventModifierState.js\n ** module id = 167\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/getEventModifierState.js?");
|
||
|
||
/***/ },
|
||
/* 168 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\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 HTMLDOMPropertyConfig\n */\n\n/*jslint bitwise: true*/\n\n'use strict';\n\nvar DOMProperty = __webpack_require__(63);\nvar ExecutionEnvironment = __webpack_require__(77);\n\nvar MUST_USE_ATTRIBUTE = DOMProperty.injection.MUST_USE_ATTRIBUTE;\nvar MUST_USE_PROPERTY = DOMProperty.injection.MUST_USE_PROPERTY;\nvar HAS_BOOLEAN_VALUE = DOMProperty.injection.HAS_BOOLEAN_VALUE;\nvar HAS_SIDE_EFFECTS = DOMProperty.injection.HAS_SIDE_EFFECTS;\nvar HAS_NUMERIC_VALUE = DOMProperty.injection.HAS_NUMERIC_VALUE;\nvar HAS_POSITIVE_NUMERIC_VALUE =\n DOMProperty.injection.HAS_POSITIVE_NUMERIC_VALUE;\nvar HAS_OVERLOADED_BOOLEAN_VALUE =\n DOMProperty.injection.HAS_OVERLOADED_BOOLEAN_VALUE;\n\nvar hasSVG;\nif (ExecutionEnvironment.canUseDOM) {\n var implementation = document.implementation;\n hasSVG = (\n implementation &&\n implementation.hasFeature &&\n implementation.hasFeature(\n 'http://www.w3.org/TR/SVG11/feature#BasicStructure',\n '1.1'\n )\n );\n}\n\n\nvar HTMLDOMPropertyConfig = {\n isCustomAttribute: RegExp.prototype.test.bind(\n /^(data|aria)-[a-z_][a-z\\d_.\\-]*$/\n ),\n Properties: {\n /**\n * Standard Properties\n */\n accept: null,\n acceptCharset: null,\n accessKey: null,\n action: null,\n allowFullScreen: MUST_USE_ATTRIBUTE | HAS_BOOLEAN_VALUE,\n allowTransparency: MUST_USE_ATTRIBUTE,\n alt: null,\n async: HAS_BOOLEAN_VALUE,\n autoComplete: null,\n // autoFocus is polyfilled/normalized by AutoFocusMixin\n // autoFocus: HAS_BOOLEAN_VALUE,\n autoPlay: HAS_BOOLEAN_VALUE,\n cellPadding: null,\n cellSpacing: null,\n charSet: MUST_USE_ATTRIBUTE,\n checked: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE,\n classID: MUST_USE_ATTRIBUTE,\n // To set className on SVG elements, it's necessary to use .setAttribute;\n // this works on HTML elements too in all browsers except IE8. Conveniently,\n // IE8 doesn't support SVG and so we can simply use the attribute in\n // browsers that support SVG and the property in browsers that don't,\n // regardless of whether the element is HTML or SVG.\n className: hasSVG ? MUST_USE_ATTRIBUTE : MUST_USE_PROPERTY,\n cols: MUST_USE_ATTRIBUTE | HAS_POSITIVE_NUMERIC_VALUE,\n colSpan: null,\n content: null,\n contentEditable: null,\n contextMenu: MUST_USE_ATTRIBUTE,\n controls: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE,\n coords: null,\n crossOrigin: null,\n data: null, // For `<object />` acts as `src`.\n dateTime: MUST_USE_ATTRIBUTE,\n defer: HAS_BOOLEAN_VALUE,\n dir: null,\n disabled: MUST_USE_ATTRIBUTE | HAS_BOOLEAN_VALUE,\n download: HAS_OVERLOADED_BOOLEAN_VALUE,\n draggable: null,\n encType: null,\n form: MUST_USE_ATTRIBUTE,\n formAction: MUST_USE_ATTRIBUTE,\n formEncType: MUST_USE_ATTRIBUTE,\n formMethod: MUST_USE_ATTRIBUTE,\n formNoValidate: HAS_BOOLEAN_VALUE,\n formTarget: MUST_USE_ATTRIBUTE,\n frameBorder: MUST_USE_ATTRIBUTE,\n headers: null,\n height: MUST_USE_ATTRIBUTE,\n hidden: MUST_USE_ATTRIBUTE | HAS_BOOLEAN_VALUE,\n high: null,\n href: null,\n hrefLang: null,\n htmlFor: null,\n httpEquiv: null,\n icon: null,\n id: MUST_USE_PROPERTY,\n label: null,\n lang: null,\n list: MUST_USE_ATTRIBUTE,\n loop: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE,\n low: null,\n manifest: MUST_USE_ATTRIBUTE,\n marginHeight: null,\n marginWidth: null,\n max: null,\n maxLength: MUST_USE_ATTRIBUTE,\n media: MUST_USE_ATTRIBUTE,\n mediaGroup: null,\n method: null,\n min: null,\n multiple: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE,\n muted: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE,\n name: null,\n noValidate: HAS_BOOLEAN_VALUE,\n open: HAS_BOOLEAN_VALUE,\n optimum: null,\n pattern: null,\n placeholder: null,\n poster: null,\n preload: null,\n radioGroup: null,\n readOnly: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE,\n rel: null,\n required: HAS_BOOLEAN_VALUE,\n role: MUST_USE_ATTRIBUTE,\n rows: MUST_USE_ATTRIBUTE | HAS_POSITIVE_NUMERIC_VALUE,\n rowSpan: null,\n sandbox: null,\n scope: null,\n scoped: HAS_BOOLEAN_VALUE,\n scrolling: null,\n seamless: MUST_USE_ATTRIBUTE | HAS_BOOLEAN_VALUE,\n selected: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE,\n shape: null,\n size: MUST_USE_ATTRIBUTE | HAS_POSITIVE_NUMERIC_VALUE,\n sizes: MUST_USE_ATTRIBUTE,\n span: HAS_POSITIVE_NUMERIC_VALUE,\n spellCheck: null,\n src: null,\n srcDoc: MUST_USE_PROPERTY,\n srcSet: MUST_USE_ATTRIBUTE,\n start: HAS_NUMERIC_VALUE,\n step: null,\n style: null,\n tabIndex: null,\n target: null,\n title: null,\n type: null,\n useMap: null,\n value: MUST_USE_PROPERTY | HAS_SIDE_EFFECTS,\n width: MUST_USE_ATTRIBUTE,\n wmode: MUST_USE_ATTRIBUTE,\n\n /**\n * Non-standard Properties\n */\n // autoCapitalize and autoCorrect are supported in Mobile Safari for\n // keyboard hints.\n autoCapitalize: null,\n autoCorrect: null,\n // itemProp, itemScope, itemType are for\n // Microdata support. See http://schema.org/docs/gs.html\n itemProp: MUST_USE_ATTRIBUTE,\n itemScope: MUST_USE_ATTRIBUTE | HAS_BOOLEAN_VALUE,\n itemType: MUST_USE_ATTRIBUTE,\n // itemID and itemRef are for Microdata support as well but\n // only specified in the the WHATWG spec document. See\n // https://html.spec.whatwg.org/multipage/microdata.html#microdata-dom-api\n itemID: MUST_USE_ATTRIBUTE,\n itemRef: MUST_USE_ATTRIBUTE,\n // property is supported for OpenGraph in meta tags.\n property: null,\n // IE-only attribute that controls focus behavior\n unselectable: MUST_USE_ATTRIBUTE\n },\n DOMAttributeNames: {\n acceptCharset: 'accept-charset',\n className: 'class',\n htmlFor: 'for',\n httpEquiv: 'http-equiv'\n },\n DOMPropertyNames: {\n autoCapitalize: 'autocapitalize',\n autoComplete: 'autocomplete',\n autoCorrect: 'autocorrect',\n autoFocus: 'autofocus',\n autoPlay: 'autoplay',\n // `encoding` is equivalent to `enctype`, IE8 lacks an `enctype` setter.\n // http://www.w3.org/TR/html5/forms.html#dom-fs-encoding\n encType: 'encoding',\n hrefLang: 'hreflang',\n radioGroup: 'radiogroup',\n spellCheck: 'spellcheck',\n srcDoc: 'srcdoc',\n srcSet: 'srcset'\n }\n};\n\nmodule.exports = HTMLDOMPropertyConfig;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/HTMLDOMPropertyConfig.js\n ** module id = 168\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/HTMLDOMPropertyConfig.js?");
|
||
|
||
/***/ },
|
||
/* 169 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\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 MobileSafariClickEventPlugin\n * @typechecks static-only\n */\n\n'use strict';\n\nvar EventConstants = __webpack_require__(66);\n\nvar emptyFunction = __webpack_require__(83);\n\nvar topLevelTypes = EventConstants.topLevelTypes;\n\n/**\n * Mobile Safari does not fire properly bubble click events on non-interactive\n * elements, which means delegated click listeners do not fire. The workaround\n * for this bug involves attaching an empty click listener on the target node.\n *\n * This particular plugin works around the bug by attaching an empty click\n * listener on `touchstart` (which does fire on every element).\n */\nvar MobileSafariClickEventPlugin = {\n\n eventTypes: null,\n\n /**\n * @param {string} topLevelType Record from `EventConstants`.\n * @param {DOMEventTarget} topLevelTarget The listening component root node.\n * @param {string} topLevelTargetID ID of `topLevelTarget`.\n * @param {object} nativeEvent Native browser event.\n * @return {*} An accumulation of synthetic events.\n * @see {EventPluginHub.extractEvents}\n */\n extractEvents: function(\n topLevelType,\n topLevelTarget,\n topLevelTargetID,\n nativeEvent) {\n if (topLevelType === topLevelTypes.topTouchStart) {\n var target = nativeEvent.target;\n if (target && !target.onclick) {\n target.onclick = emptyFunction;\n }\n }\n }\n\n};\n\nmodule.exports = MobileSafariClickEventPlugin;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/MobileSafariClickEventPlugin.js\n ** module id = 169\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/MobileSafariClickEventPlugin.js?");
|
||
|
||
/***/ },
|
||
/* 170 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\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 ReactBrowserComponentMixin\n */\n\n'use strict';\n\nvar findDOMNode = __webpack_require__(171);\n\nvar ReactBrowserComponentMixin = {\n /**\n * Returns the DOM node rendered by this component.\n *\n * @return {DOMElement} The root node of this component.\n * @final\n * @protected\n */\n getDOMNode: function() {\n return findDOMNode(this);\n }\n};\n\nmodule.exports = ReactBrowserComponentMixin;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactBrowserComponentMixin.js\n ** module id = 170\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ReactBrowserComponentMixin.js?");
|
||
|
||
/***/ },
|
||
/* 171 */
|
||
/***/ 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 findDOMNode\n * @typechecks static-only\n */\n\n'use strict';\n\nvar ReactCurrentOwner = __webpack_require__(78);\nvar ReactInstanceMap = __webpack_require__(91);\nvar ReactMount = __webpack_require__(61);\n\nvar invariant = __webpack_require__(64);\nvar isNode = __webpack_require__(108);\nvar warning = __webpack_require__(82);\n\n/**\n * Returns the DOM node rendered by this element.\n *\n * @param {ReactComponent|DOMElement} componentOrElement\n * @return {DOMElement} The root node of this element.\n */\nfunction findDOMNode(componentOrElement) {\n if (\"production\" !== process.env.NODE_ENV) {\n var owner = ReactCurrentOwner.current;\n if (owner !== null) {\n (\"production\" !== process.env.NODE_ENV ? warning(\n owner._warnedAboutRefsInRender,\n '%s is accessing getDOMNode or findDOMNode inside its render(). ' +\n 'render() should be a pure function of props and state. It should ' +\n 'never access something that requires stale data from the previous ' +\n 'render, such as refs. Move this logic to componentDidMount and ' +\n 'componentDidUpdate instead.',\n owner.getName() || 'A component'\n ) : null);\n owner._warnedAboutRefsInRender = true;\n }\n }\n if (componentOrElement == null) {\n return null;\n }\n if (isNode(componentOrElement)) {\n return componentOrElement;\n }\n if (ReactInstanceMap.has(componentOrElement)) {\n return ReactMount.getNodeFromInstance(componentOrElement);\n }\n (\"production\" !== process.env.NODE_ENV ? invariant(\n componentOrElement.render == null ||\n typeof componentOrElement.render !== 'function',\n 'Component (with keys: %s) contains `render` method ' +\n 'but is not mounted in the DOM',\n Object.keys(componentOrElement)\n ) : invariant(componentOrElement.render == null ||\n typeof componentOrElement.render !== 'function'));\n (\"production\" !== process.env.NODE_ENV ? invariant(\n false,\n 'Element appears to be neither ReactComponent nor DOMNode (keys: %s)',\n Object.keys(componentOrElement)\n ) : invariant(false));\n}\n\nmodule.exports = findDOMNode;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/findDOMNode.js\n ** module id = 171\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/findDOMNode.js?");
|
||
|
||
/***/ },
|
||
/* 172 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\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 ReactDefaultBatchingStrategy\n */\n\n'use strict';\n\nvar ReactUpdates = __webpack_require__(101);\nvar Transaction = __webpack_require__(104);\n\nvar assign = __webpack_require__(75);\nvar emptyFunction = __webpack_require__(83);\n\nvar RESET_BATCHED_UPDATES = {\n initialize: emptyFunction,\n close: function() {\n ReactDefaultBatchingStrategy.isBatchingUpdates = false;\n }\n};\n\nvar FLUSH_BATCHED_UPDATES = {\n initialize: emptyFunction,\n close: ReactUpdates.flushBatchedUpdates.bind(ReactUpdates)\n};\n\nvar TRANSACTION_WRAPPERS = [FLUSH_BATCHED_UPDATES, RESET_BATCHED_UPDATES];\n\nfunction ReactDefaultBatchingStrategyTransaction() {\n this.reinitializeTransaction();\n}\n\nassign(\n ReactDefaultBatchingStrategyTransaction.prototype,\n Transaction.Mixin,\n {\n getTransactionWrappers: function() {\n return TRANSACTION_WRAPPERS;\n }\n }\n);\n\nvar transaction = new ReactDefaultBatchingStrategyTransaction();\n\nvar ReactDefaultBatchingStrategy = {\n isBatchingUpdates: false,\n\n /**\n * Call the provided function in a context within which calls to `setState`\n * and friends are batched such that components aren't updated unnecessarily.\n */\n batchedUpdates: function(callback, a, b, c, d) {\n var alreadyBatchingUpdates = ReactDefaultBatchingStrategy.isBatchingUpdates;\n\n ReactDefaultBatchingStrategy.isBatchingUpdates = true;\n\n // The code is written this way to avoid extra allocations\n if (alreadyBatchingUpdates) {\n callback(a, b, c, d);\n } else {\n transaction.perform(callback, null, a, b, c, d);\n }\n }\n};\n\nmodule.exports = ReactDefaultBatchingStrategy;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactDefaultBatchingStrategy.js\n ** module id = 172\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ReactDefaultBatchingStrategy.js?");
|
||
|
||
/***/ },
|
||
/* 173 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\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 ReactDOMButton\n */\n\n'use strict';\n\nvar AutoFocusMixin = __webpack_require__(174);\nvar ReactBrowserComponentMixin = __webpack_require__(170);\nvar ReactClass = __webpack_require__(120);\nvar ReactElement = __webpack_require__(79);\n\nvar keyMirror = __webpack_require__(67);\n\nvar button = ReactElement.createFactory('button');\n\nvar mouseListenerNames = keyMirror({\n onClick: true,\n onDoubleClick: true,\n onMouseDown: true,\n onMouseMove: true,\n onMouseUp: true,\n onClickCapture: true,\n onDoubleClickCapture: true,\n onMouseDownCapture: true,\n onMouseMoveCapture: true,\n onMouseUpCapture: true\n});\n\n/**\n * Implements a <button> native component that does not receive mouse events\n * when `disabled` is set.\n */\nvar ReactDOMButton = ReactClass.createClass({\n displayName: 'ReactDOMButton',\n tagName: 'BUTTON',\n\n mixins: [AutoFocusMixin, ReactBrowserComponentMixin],\n\n render: function() {\n var props = {};\n\n // Copy the props; except the mouse listeners if we're disabled\n for (var key in this.props) {\n if (this.props.hasOwnProperty(key) &&\n (!this.props.disabled || !mouseListenerNames[key])) {\n props[key] = this.props[key];\n }\n }\n\n return button(props, this.props.children);\n }\n\n});\n\nmodule.exports = ReactDOMButton;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactDOMButton.js\n ** module id = 173\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ReactDOMButton.js?");
|
||
|
||
/***/ },
|
||
/* 174 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\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 AutoFocusMixin\n * @typechecks static-only\n */\n\n'use strict';\n\nvar focusNode = __webpack_require__(175);\n\nvar AutoFocusMixin = {\n componentDidMount: function() {\n if (this.props.autoFocus) {\n focusNode(this.getDOMNode());\n }\n }\n};\n\nmodule.exports = AutoFocusMixin;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/AutoFocusMixin.js\n ** module id = 174\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/AutoFocusMixin.js?");
|
||
|
||
/***/ },
|
||
/* 175 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("/**\n * Copyright 2014-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 focusNode\n */\n\n\"use strict\";\n\n/**\n * @param {DOMElement} node input/textarea to focus\n */\nfunction focusNode(node) {\n // IE8 can throw \"Can't move focus to the control because it is invisible,\n // not enabled, or of a type that does not accept the focus.\" for all kinds of\n // reasons that are too expensive and fragile to test.\n try {\n node.focus();\n } catch(e) {\n }\n}\n\nmodule.exports = focusNode;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/focusNode.js\n ** module id = 175\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/focusNode.js?");
|
||
|
||
/***/ },
|
||
/* 176 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\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 ReactDOMForm\n */\n\n'use strict';\n\nvar EventConstants = __webpack_require__(66);\nvar LocalEventTrapMixin = __webpack_require__(177);\nvar ReactBrowserComponentMixin = __webpack_require__(170);\nvar ReactClass = __webpack_require__(120);\nvar ReactElement = __webpack_require__(79);\n\nvar form = ReactElement.createFactory('form');\n\n/**\n * Since onSubmit doesn't bubble OR capture on the top level in IE8, we need\n * to capture it on the <form> element itself. There are lots of hacks we could\n * do to accomplish this, but the most reliable is to make <form> a\n * composite component and use `componentDidMount` to attach the event handlers.\n */\nvar ReactDOMForm = ReactClass.createClass({\n displayName: 'ReactDOMForm',\n tagName: 'FORM',\n\n mixins: [ReactBrowserComponentMixin, LocalEventTrapMixin],\n\n render: function() {\n // TODO: Instead of using `ReactDOM` directly, we should use JSX. However,\n // `jshint` fails to parse JSX so in order for linting to work in the open\n // source repo, we need to just use `ReactDOM.form`.\n return form(this.props);\n },\n\n componentDidMount: function() {\n this.trapBubbledEvent(EventConstants.topLevelTypes.topReset, 'reset');\n this.trapBubbledEvent(EventConstants.topLevelTypes.topSubmit, 'submit');\n }\n});\n\nmodule.exports = ReactDOMForm;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactDOMForm.js\n ** module id = 176\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ReactDOMForm.js?");
|
||
|
||
/***/ },
|
||
/* 177 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/* WEBPACK VAR INJECTION */(function(process) {/**\n * Copyright 2014-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 LocalEventTrapMixin\n */\n\n'use strict';\n\nvar ReactBrowserEventEmitter = __webpack_require__(65);\n\nvar accumulateInto = __webpack_require__(71);\nvar forEachAccumulated = __webpack_require__(72);\nvar invariant = __webpack_require__(64);\n\nfunction remove(event) {\n event.remove();\n}\n\nvar LocalEventTrapMixin = {\n trapBubbledEvent:function(topLevelType, handlerBaseName) {\n (\"production\" !== process.env.NODE_ENV ? invariant(this.isMounted(), 'Must be mounted to trap events') : invariant(this.isMounted()));\n // If a component renders to null or if another component fatals and causes\n // the state of the tree to be corrupted, `node` here can be null.\n var node = this.getDOMNode();\n (\"production\" !== process.env.NODE_ENV ? invariant(\n node,\n 'LocalEventTrapMixin.trapBubbledEvent(...): Requires node to be rendered.'\n ) : invariant(node));\n var listener = ReactBrowserEventEmitter.trapBubbledEvent(\n topLevelType,\n handlerBaseName,\n node\n );\n this._localEventListeners =\n accumulateInto(this._localEventListeners, listener);\n },\n\n // trapCapturedEvent would look nearly identical. We don't implement that\n // method because it isn't currently needed.\n\n componentWillUnmount:function() {\n if (this._localEventListeners) {\n forEachAccumulated(this._localEventListeners, remove);\n }\n }\n};\n\nmodule.exports = LocalEventTrapMixin;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/LocalEventTrapMixin.js\n ** module id = 177\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/LocalEventTrapMixin.js?");
|
||
|
||
/***/ },
|
||
/* 178 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\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 ReactDOMImg\n */\n\n'use strict';\n\nvar EventConstants = __webpack_require__(66);\nvar LocalEventTrapMixin = __webpack_require__(177);\nvar ReactBrowserComponentMixin = __webpack_require__(170);\nvar ReactClass = __webpack_require__(120);\nvar ReactElement = __webpack_require__(79);\n\nvar img = ReactElement.createFactory('img');\n\n/**\n * Since onLoad doesn't bubble OR capture on the top level in IE8, we need to\n * capture it on the <img> element itself. There are lots of hacks we could do\n * to accomplish this, but the most reliable is to make <img> a composite\n * component and use `componentDidMount` to attach the event handlers.\n */\nvar ReactDOMImg = ReactClass.createClass({\n displayName: 'ReactDOMImg',\n tagName: 'IMG',\n\n mixins: [ReactBrowserComponentMixin, LocalEventTrapMixin],\n\n render: function() {\n return img(this.props);\n },\n\n componentDidMount: function() {\n this.trapBubbledEvent(EventConstants.topLevelTypes.topLoad, 'load');\n this.trapBubbledEvent(EventConstants.topLevelTypes.topError, 'error');\n }\n});\n\nmodule.exports = ReactDOMImg;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactDOMImg.js\n ** module id = 178\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ReactDOMImg.js?");
|
||
|
||
/***/ },
|
||
/* 179 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\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 ReactDOMIframe\n */\n\n'use strict';\n\nvar EventConstants = __webpack_require__(66);\nvar LocalEventTrapMixin = __webpack_require__(177);\nvar ReactBrowserComponentMixin = __webpack_require__(170);\nvar ReactClass = __webpack_require__(120);\nvar ReactElement = __webpack_require__(79);\n\nvar iframe = ReactElement.createFactory('iframe');\n\n/**\n * Since onLoad doesn't bubble OR capture on the top level in IE8, we need to\n * capture it on the <iframe> element itself. There are lots of hacks we could\n * do to accomplish this, but the most reliable is to make <iframe> a composite\n * component and use `componentDidMount` to attach the event handlers.\n */\nvar ReactDOMIframe = ReactClass.createClass({\n displayName: 'ReactDOMIframe',\n tagName: 'IFRAME',\n\n mixins: [ReactBrowserComponentMixin, LocalEventTrapMixin],\n\n render: function() {\n return iframe(this.props);\n },\n\n componentDidMount: function() {\n this.trapBubbledEvent(EventConstants.topLevelTypes.topLoad, 'load');\n }\n});\n\nmodule.exports = ReactDOMIframe;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactDOMIframe.js\n ** module id = 179\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ReactDOMIframe.js?");
|
||
|
||
/***/ },
|
||
/* 180 */
|
||
/***/ 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 ReactDOMInput\n */\n\n'use strict';\n\nvar AutoFocusMixin = __webpack_require__(174);\nvar DOMPropertyOperations = __webpack_require__(126);\nvar LinkedValueUtils = __webpack_require__(181);\nvar ReactBrowserComponentMixin = __webpack_require__(170);\nvar ReactClass = __webpack_require__(120);\nvar ReactElement = __webpack_require__(79);\nvar ReactMount = __webpack_require__(61);\nvar ReactUpdates = __webpack_require__(101);\n\nvar assign = __webpack_require__(75);\nvar invariant = __webpack_require__(64);\n\nvar input = ReactElement.createFactory('input');\n\nvar instancesByReactID = {};\n\nfunction forceUpdateIfMounted() {\n /*jshint validthis:true */\n if (this.isMounted()) {\n this.forceUpdate();\n }\n}\n\n/**\n * Implements an <input> native component that allows setting these optional\n * props: `checked`, `value`, `defaultChecked`, and `defaultValue`.\n *\n * If `checked` or `value` are not supplied (or null/undefined), user actions\n * that affect the checked state or value will trigger updates to the element.\n *\n * If they are supplied (and not null/undefined), the rendered element will not\n * trigger updates to the element. Instead, the props must change in order for\n * the rendered element to be updated.\n *\n * The rendered element will be initialized as unchecked (or `defaultChecked`)\n * with an empty value (or `defaultValue`).\n *\n * @see http://www.w3.org/TR/2012/WD-html5-20121025/the-input-element.html\n */\nvar ReactDOMInput = ReactClass.createClass({\n displayName: 'ReactDOMInput',\n tagName: 'INPUT',\n\n mixins: [AutoFocusMixin, LinkedValueUtils.Mixin, ReactBrowserComponentMixin],\n\n getInitialState: function() {\n var defaultValue = this.props.defaultValue;\n return {\n initialChecked: this.props.defaultChecked || false,\n initialValue: defaultValue != null ? defaultValue : null\n };\n },\n\n render: function() {\n // Clone `this.props` so we don't mutate the input.\n var props = assign({}, this.props);\n\n props.defaultChecked = null;\n props.defaultValue = null;\n\n var value = LinkedValueUtils.getValue(this);\n props.value = value != null ? value : this.state.initialValue;\n\n var checked = LinkedValueUtils.getChecked(this);\n props.checked = checked != null ? checked : this.state.initialChecked;\n\n props.onChange = this._handleChange;\n\n return input(props, this.props.children);\n },\n\n componentDidMount: function() {\n var id = ReactMount.getID(this.getDOMNode());\n instancesByReactID[id] = this;\n },\n\n componentWillUnmount: function() {\n var rootNode = this.getDOMNode();\n var id = ReactMount.getID(rootNode);\n delete instancesByReactID[id];\n },\n\n componentDidUpdate: function(prevProps, prevState, prevContext) {\n var rootNode = this.getDOMNode();\n if (this.props.checked != null) {\n DOMPropertyOperations.setValueForProperty(\n rootNode,\n 'checked',\n this.props.checked || false\n );\n }\n\n var value = LinkedValueUtils.getValue(this);\n if (value != null) {\n // Cast `value` to a string to ensure the value is set correctly. While\n // browsers typically do this as necessary, jsdom doesn't.\n DOMPropertyOperations.setValueForProperty(rootNode, 'value', '' + value);\n }\n },\n\n _handleChange: function(event) {\n var returnValue;\n var onChange = LinkedValueUtils.getOnChange(this);\n if (onChange) {\n returnValue = onChange.call(this, event);\n }\n // Here we use asap to wait until all updates have propagated, which\n // is important when using controlled components within layers:\n // https://github.com/facebook/react/issues/1698\n ReactUpdates.asap(forceUpdateIfMounted, this);\n\n var name = this.props.name;\n if (this.props.type === 'radio' && name != null) {\n var rootNode = this.getDOMNode();\n var queryRoot = rootNode;\n\n while (queryRoot.parentNode) {\n queryRoot = queryRoot.parentNode;\n }\n\n // If `rootNode.form` was non-null, then we could try `form.elements`,\n // but that sometimes behaves strangely in IE8. We could also try using\n // `form.getElementsByName`, but that will only return direct children\n // and won't include inputs that use the HTML5 `form=` attribute. Since\n // the input might not even be in a form, let's just use the global\n // `querySelectorAll` to ensure we don't miss anything.\n var group = queryRoot.querySelectorAll(\n 'input[name=' + JSON.stringify('' + name) + '][type=\"radio\"]');\n\n for (var i = 0, groupLen = group.length; i < groupLen; i++) {\n var otherNode = group[i];\n if (otherNode === rootNode ||\n otherNode.form !== rootNode.form) {\n continue;\n }\n var otherID = ReactMount.getID(otherNode);\n (\"production\" !== process.env.NODE_ENV ? invariant(\n otherID,\n 'ReactDOMInput: Mixing React and non-React radio inputs with the ' +\n 'same `name` is not supported.'\n ) : invariant(otherID));\n var otherInstance = instancesByReactID[otherID];\n (\"production\" !== process.env.NODE_ENV ? invariant(\n otherInstance,\n 'ReactDOMInput: Unknown radio button ID %s.',\n otherID\n ) : invariant(otherInstance));\n // If this is a controlled radio button group, forcing the input that\n // was previously checked to update will cause it to be come re-checked\n // as appropriate.\n ReactUpdates.asap(forceUpdateIfMounted, otherInstance);\n }\n }\n\n return returnValue;\n }\n\n});\n\nmodule.exports = ReactDOMInput;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactDOMInput.js\n ** module id = 180\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ReactDOMInput.js?");
|
||
|
||
/***/ },
|
||
/* 181 */
|
||
/***/ 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 LinkedValueUtils\n * @typechecks static-only\n */\n\n'use strict';\n\nvar ReactPropTypes = __webpack_require__(182);\n\nvar invariant = __webpack_require__(64);\n\nvar hasReadOnlyValue = {\n 'button': true,\n 'checkbox': true,\n 'image': true,\n 'hidden': true,\n 'radio': true,\n 'reset': true,\n 'submit': true\n};\n\nfunction _assertSingleLink(input) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n input.props.checkedLink == null || input.props.valueLink == null,\n 'Cannot provide a checkedLink and a valueLink. If you want to use ' +\n 'checkedLink, you probably don\\'t want to use valueLink and vice versa.'\n ) : invariant(input.props.checkedLink == null || input.props.valueLink == null));\n}\nfunction _assertValueLink(input) {\n _assertSingleLink(input);\n (\"production\" !== process.env.NODE_ENV ? invariant(\n input.props.value == null && input.props.onChange == null,\n 'Cannot provide a valueLink and a value or onChange event. If you want ' +\n 'to use value or onChange, you probably don\\'t want to use valueLink.'\n ) : invariant(input.props.value == null && input.props.onChange == null));\n}\n\nfunction _assertCheckedLink(input) {\n _assertSingleLink(input);\n (\"production\" !== process.env.NODE_ENV ? invariant(\n input.props.checked == null && input.props.onChange == null,\n 'Cannot provide a checkedLink and a checked property or onChange event. ' +\n 'If you want to use checked or onChange, you probably don\\'t want to ' +\n 'use checkedLink'\n ) : invariant(input.props.checked == null && input.props.onChange == null));\n}\n\n/**\n * @param {SyntheticEvent} e change event to handle\n */\nfunction _handleLinkedValueChange(e) {\n /*jshint validthis:true */\n this.props.valueLink.requestChange(e.target.value);\n}\n\n/**\n * @param {SyntheticEvent} e change event to handle\n */\nfunction _handleLinkedCheckChange(e) {\n /*jshint validthis:true */\n this.props.checkedLink.requestChange(e.target.checked);\n}\n\n/**\n * Provide a linked `value` attribute for controlled forms. You should not use\n * this outside of the ReactDOM controlled form components.\n */\nvar LinkedValueUtils = {\n Mixin: {\n propTypes: {\n value: function(props, propName, componentName) {\n if (!props[propName] ||\n hasReadOnlyValue[props.type] ||\n props.onChange ||\n props.readOnly ||\n props.disabled) {\n return null;\n }\n return new Error(\n 'You provided a `value` prop to a form field without an ' +\n '`onChange` handler. This will render a read-only field. If ' +\n 'the field should be mutable use `defaultValue`. Otherwise, ' +\n 'set either `onChange` or `readOnly`.'\n );\n },\n checked: function(props, propName, componentName) {\n if (!props[propName] ||\n props.onChange ||\n props.readOnly ||\n props.disabled) {\n return null;\n }\n return new Error(\n 'You provided a `checked` prop to a form field without an ' +\n '`onChange` handler. This will render a read-only field. If ' +\n 'the field should be mutable use `defaultChecked`. Otherwise, ' +\n 'set either `onChange` or `readOnly`.'\n );\n },\n onChange: ReactPropTypes.func\n }\n },\n\n /**\n * @param {ReactComponent} input Form component\n * @return {*} current value of the input either from value prop or link.\n */\n getValue: function(input) {\n if (input.props.valueLink) {\n _assertValueLink(input);\n return input.props.valueLink.value;\n }\n return input.props.value;\n },\n\n /**\n * @param {ReactComponent} input Form component\n * @return {*} current checked status of the input either from checked prop\n * or link.\n */\n getChecked: function(input) {\n if (input.props.checkedLink) {\n _assertCheckedLink(input);\n return input.props.checkedLink.value;\n }\n return input.props.checked;\n },\n\n /**\n * @param {ReactComponent} input Form component\n * @return {function} change callback either from onChange prop or link.\n */\n getOnChange: function(input) {\n if (input.props.valueLink) {\n _assertValueLink(input);\n return _handleLinkedValueChange;\n } else if (input.props.checkedLink) {\n _assertCheckedLink(input);\n return _handleLinkedCheckChange;\n }\n return input.props.onChange;\n }\n};\n\nmodule.exports = LinkedValueUtils;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/LinkedValueUtils.js\n ** module id = 181\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/LinkedValueUtils.js?");
|
||
|
||
/***/ },
|
||
/* 182 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\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 ReactPropTypes\n */\n\n'use strict';\n\nvar ReactElement = __webpack_require__(79);\nvar ReactFragment = __webpack_require__(85);\nvar ReactPropTypeLocationNames = __webpack_require__(87);\n\nvar emptyFunction = __webpack_require__(83);\n\n/**\n * Collection of methods that allow declaration and validation of props that are\n * supplied to React components. Example usage:\n *\n * var Props = require('ReactPropTypes');\n * var MyArticle = React.createClass({\n * propTypes: {\n * // An optional string prop named \"description\".\n * description: Props.string,\n *\n * // A required enum prop named \"category\".\n * category: Props.oneOf(['News','Photos']).isRequired,\n *\n * // A prop named \"dialog\" that requires an instance of Dialog.\n * dialog: Props.instanceOf(Dialog).isRequired\n * },\n * render: function() { ... }\n * });\n *\n * A more formal specification of how these methods are used:\n *\n * type := array|bool|func|object|number|string|oneOf([...])|instanceOf(...)\n * decl := ReactPropTypes.{type}(.isRequired)?\n *\n * Each and every declaration produces a function with the same signature. This\n * allows the creation of custom validation functions. For example:\n *\n * var MyLink = React.createClass({\n * propTypes: {\n * // An optional string or URI prop named \"href\".\n * href: function(props, propName, componentName) {\n * var propValue = props[propName];\n * if (propValue != null && typeof propValue !== 'string' &&\n * !(propValue instanceof URI)) {\n * return new Error(\n * 'Expected a string or an URI for ' + propName + ' in ' +\n * componentName\n * );\n * }\n * }\n * },\n * render: function() {...}\n * });\n *\n * @internal\n */\n\nvar ANONYMOUS = '<<anonymous>>';\n\nvar elementTypeChecker = createElementTypeChecker();\nvar nodeTypeChecker = createNodeChecker();\n\nvar ReactPropTypes = {\n array: createPrimitiveTypeChecker('array'),\n bool: createPrimitiveTypeChecker('boolean'),\n func: createPrimitiveTypeChecker('function'),\n number: createPrimitiveTypeChecker('number'),\n object: createPrimitiveTypeChecker('object'),\n string: createPrimitiveTypeChecker('string'),\n\n any: createAnyTypeChecker(),\n arrayOf: createArrayOfTypeChecker,\n element: elementTypeChecker,\n instanceOf: createInstanceTypeChecker,\n node: nodeTypeChecker,\n objectOf: createObjectOfTypeChecker,\n oneOf: createEnumTypeChecker,\n oneOfType: createUnionTypeChecker,\n shape: createShapeTypeChecker\n};\n\nfunction createChainableTypeChecker(validate) {\n function checkType(isRequired, props, propName, componentName, location) {\n componentName = componentName || ANONYMOUS;\n if (props[propName] == null) {\n var locationName = ReactPropTypeLocationNames[location];\n if (isRequired) {\n return new Error(\n (\"Required \" + locationName + \" `\" + propName + \"` was not specified in \") +\n (\"`\" + componentName + \"`.\")\n );\n }\n return null;\n } else {\n return validate(props, propName, componentName, location);\n }\n }\n\n var chainedCheckType = checkType.bind(null, false);\n chainedCheckType.isRequired = checkType.bind(null, true);\n\n return chainedCheckType;\n}\n\nfunction createPrimitiveTypeChecker(expectedType) {\n function validate(props, propName, componentName, location) {\n var propValue = props[propName];\n var propType = getPropType(propValue);\n if (propType !== expectedType) {\n var locationName = ReactPropTypeLocationNames[location];\n // `propValue` being instance of, say, date/regexp, pass the 'object'\n // check, but we can offer a more precise error message here rather than\n // 'of type `object`'.\n var preciseType = getPreciseType(propValue);\n\n return new Error(\n (\"Invalid \" + locationName + \" `\" + propName + \"` of type `\" + preciseType + \"` \") +\n (\"supplied to `\" + componentName + \"`, expected `\" + expectedType + \"`.\")\n );\n }\n return null;\n }\n return createChainableTypeChecker(validate);\n}\n\nfunction createAnyTypeChecker() {\n return createChainableTypeChecker(emptyFunction.thatReturns(null));\n}\n\nfunction createArrayOfTypeChecker(typeChecker) {\n function validate(props, propName, componentName, location) {\n var propValue = props[propName];\n if (!Array.isArray(propValue)) {\n var locationName = ReactPropTypeLocationNames[location];\n var propType = getPropType(propValue);\n return new Error(\n (\"Invalid \" + locationName + \" `\" + propName + \"` of type \") +\n (\"`\" + propType + \"` supplied to `\" + componentName + \"`, expected an array.\")\n );\n }\n for (var i = 0; i < propValue.length; i++) {\n var error = typeChecker(propValue, i, componentName, location);\n if (error instanceof Error) {\n return error;\n }\n }\n return null;\n }\n return createChainableTypeChecker(validate);\n}\n\nfunction createElementTypeChecker() {\n function validate(props, propName, componentName, location) {\n if (!ReactElement.isValidElement(props[propName])) {\n var locationName = ReactPropTypeLocationNames[location];\n return new Error(\n (\"Invalid \" + locationName + \" `\" + propName + \"` supplied to \") +\n (\"`\" + componentName + \"`, expected a ReactElement.\")\n );\n }\n return null;\n }\n return createChainableTypeChecker(validate);\n}\n\nfunction createInstanceTypeChecker(expectedClass) {\n function validate(props, propName, componentName, location) {\n if (!(props[propName] instanceof expectedClass)) {\n var locationName = ReactPropTypeLocationNames[location];\n var expectedClassName = expectedClass.name || ANONYMOUS;\n return new Error(\n (\"Invalid \" + locationName + \" `\" + propName + \"` supplied to \") +\n (\"`\" + componentName + \"`, expected instance of `\" + expectedClassName + \"`.\")\n );\n }\n return null;\n }\n return createChainableTypeChecker(validate);\n}\n\nfunction createEnumTypeChecker(expectedValues) {\n function validate(props, propName, componentName, location) {\n var propValue = props[propName];\n for (var i = 0; i < expectedValues.length; i++) {\n if (propValue === expectedValues[i]) {\n return null;\n }\n }\n\n var locationName = ReactPropTypeLocationNames[location];\n var valuesString = JSON.stringify(expectedValues);\n return new Error(\n (\"Invalid \" + locationName + \" `\" + propName + \"` of value `\" + propValue + \"` \") +\n (\"supplied to `\" + componentName + \"`, expected one of \" + valuesString + \".\")\n );\n }\n return createChainableTypeChecker(validate);\n}\n\nfunction createObjectOfTypeChecker(typeChecker) {\n function validate(props, propName, componentName, location) {\n var propValue = props[propName];\n var propType = getPropType(propValue);\n if (propType !== 'object') {\n var locationName = ReactPropTypeLocationNames[location];\n return new Error(\n (\"Invalid \" + locationName + \" `\" + propName + \"` of type \") +\n (\"`\" + propType + \"` supplied to `\" + componentName + \"`, expected an object.\")\n );\n }\n for (var key in propValue) {\n if (propValue.hasOwnProperty(key)) {\n var error = typeChecker(propValue, key, componentName, location);\n if (error instanceof Error) {\n return error;\n }\n }\n }\n return null;\n }\n return createChainableTypeChecker(validate);\n}\n\nfunction createUnionTypeChecker(arrayOfTypeCheckers) {\n function validate(props, propName, componentName, location) {\n for (var i = 0; i < arrayOfTypeCheckers.length; i++) {\n var checker = arrayOfTypeCheckers[i];\n if (checker(props, propName, componentName, location) == null) {\n return null;\n }\n }\n\n var locationName = ReactPropTypeLocationNames[location];\n return new Error(\n (\"Invalid \" + locationName + \" `\" + propName + \"` supplied to \") +\n (\"`\" + componentName + \"`.\")\n );\n }\n return createChainableTypeChecker(validate);\n}\n\nfunction createNodeChecker() {\n function validate(props, propName, componentName, location) {\n if (!isNode(props[propName])) {\n var locationName = ReactPropTypeLocationNames[location];\n return new Error(\n (\"Invalid \" + locationName + \" `\" + propName + \"` supplied to \") +\n (\"`\" + componentName + \"`, expected a ReactNode.\")\n );\n }\n return null;\n }\n return createChainableTypeChecker(validate);\n}\n\nfunction createShapeTypeChecker(shapeTypes) {\n function validate(props, propName, componentName, location) {\n var propValue = props[propName];\n var propType = getPropType(propValue);\n if (propType !== 'object') {\n var locationName = ReactPropTypeLocationNames[location];\n return new Error(\n (\"Invalid \" + locationName + \" `\" + propName + \"` of type `\" + propType + \"` \") +\n (\"supplied to `\" + componentName + \"`, expected `object`.\")\n );\n }\n for (var key in shapeTypes) {\n var checker = shapeTypes[key];\n if (!checker) {\n continue;\n }\n var error = checker(propValue, key, componentName, location);\n if (error) {\n return error;\n }\n }\n return null;\n }\n return createChainableTypeChecker(validate);\n}\n\nfunction isNode(propValue) {\n switch (typeof propValue) {\n case 'number':\n case 'string':\n case 'undefined':\n return true;\n case 'boolean':\n return !propValue;\n case 'object':\n if (Array.isArray(propValue)) {\n return propValue.every(isNode);\n }\n if (propValue === null || ReactElement.isValidElement(propValue)) {\n return true;\n }\n propValue = ReactFragment.extractIfFragment(propValue);\n for (var k in propValue) {\n if (!isNode(propValue[k])) {\n return false;\n }\n }\n return true;\n default:\n return false;\n }\n}\n\n// Equivalent of `typeof` but with special handling for array and regexp.\nfunction getPropType(propValue) {\n var propType = typeof propValue;\n if (Array.isArray(propValue)) {\n return 'array';\n }\n if (propValue instanceof RegExp) {\n // Old webkits (at least until Android 4.0) return 'function' rather than\n // 'object' for typeof a RegExp. We'll normalize this here so that /bla/\n // passes PropTypes.object.\n return 'object';\n }\n return propType;\n}\n\n// This handles more types than `getPropType`. Only used for error messages.\n// See `createPrimitiveTypeChecker`.\nfunction getPreciseType(propValue) {\n var propType = getPropType(propValue);\n if (propType === 'object') {\n if (propValue instanceof Date) {\n return 'date';\n } else if (propValue instanceof RegExp) {\n return 'regexp';\n }\n }\n return propType;\n}\n\nmodule.exports = ReactPropTypes;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactPropTypes.js\n ** module id = 182\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ReactPropTypes.js?");
|
||
|
||
/***/ },
|
||
/* 183 */
|
||
/***/ 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 ReactDOMOption\n */\n\n'use strict';\n\nvar ReactBrowserComponentMixin = __webpack_require__(170);\nvar ReactClass = __webpack_require__(120);\nvar ReactElement = __webpack_require__(79);\n\nvar warning = __webpack_require__(82);\n\nvar option = ReactElement.createFactory('option');\n\n/**\n * Implements an <option> native component that warns when `selected` is set.\n */\nvar ReactDOMOption = ReactClass.createClass({\n displayName: 'ReactDOMOption',\n tagName: 'OPTION',\n\n mixins: [ReactBrowserComponentMixin],\n\n componentWillMount: function() {\n // TODO (yungsters): Remove support for `selected` in <option>.\n if (\"production\" !== process.env.NODE_ENV) {\n (\"production\" !== process.env.NODE_ENV ? warning(\n this.props.selected == null,\n 'Use the `defaultValue` or `value` props on <select> instead of ' +\n 'setting `selected` on <option>.'\n ) : null);\n }\n },\n\n render: function() {\n return option(this.props, this.props.children);\n }\n\n});\n\nmodule.exports = ReactDOMOption;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactDOMOption.js\n ** module id = 183\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ReactDOMOption.js?");
|
||
|
||
/***/ },
|
||
/* 184 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\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 ReactDOMSelect\n */\n\n'use strict';\n\nvar AutoFocusMixin = __webpack_require__(174);\nvar LinkedValueUtils = __webpack_require__(181);\nvar ReactBrowserComponentMixin = __webpack_require__(170);\nvar ReactClass = __webpack_require__(120);\nvar ReactElement = __webpack_require__(79);\nvar ReactUpdates = __webpack_require__(101);\n\nvar assign = __webpack_require__(75);\n\nvar select = ReactElement.createFactory('select');\n\nfunction updateOptionsIfPendingUpdateAndMounted() {\n /*jshint validthis:true */\n if (this._pendingUpdate) {\n this._pendingUpdate = false;\n var value = LinkedValueUtils.getValue(this);\n if (value != null && this.isMounted()) {\n updateOptions(this, value);\n }\n }\n}\n\n/**\n * Validation function for `value` and `defaultValue`.\n * @private\n */\nfunction selectValueType(props, propName, componentName) {\n if (props[propName] == null) {\n return null;\n }\n if (props.multiple) {\n if (!Array.isArray(props[propName])) {\n return new Error(\n (\"The `\" + propName + \"` prop supplied to <select> must be an array if \") +\n (\"`multiple` is true.\")\n );\n }\n } else {\n if (Array.isArray(props[propName])) {\n return new Error(\n (\"The `\" + propName + \"` prop supplied to <select> must be a scalar \") +\n (\"value if `multiple` is false.\")\n );\n }\n }\n}\n\n/**\n * @param {ReactComponent} component Instance of ReactDOMSelect\n * @param {*} propValue A stringable (with `multiple`, a list of stringables).\n * @private\n */\nfunction updateOptions(component, propValue) {\n var selectedValue, i, l;\n var options = component.getDOMNode().options;\n\n if (component.props.multiple) {\n selectedValue = {};\n for (i = 0, l = propValue.length; i < l; i++) {\n selectedValue['' + propValue[i]] = true;\n }\n for (i = 0, l = options.length; i < l; i++) {\n var selected = selectedValue.hasOwnProperty(options[i].value);\n if (options[i].selected !== selected) {\n options[i].selected = selected;\n }\n }\n } else {\n // Do not set `select.value` as exact behavior isn't consistent across all\n // browsers for all cases.\n selectedValue = '' + propValue;\n for (i = 0, l = options.length; i < l; i++) {\n if (options[i].value === selectedValue) {\n options[i].selected = true;\n return;\n }\n }\n if (options.length) {\n options[0].selected = true;\n }\n }\n}\n\n/**\n * Implements a <select> native component that allows optionally setting the\n * props `value` and `defaultValue`. If `multiple` is false, the prop must be a\n * stringable. If `multiple` is true, the prop must be an array of stringables.\n *\n * If `value` is not supplied (or null/undefined), user actions that change the\n * selected option will trigger updates to the rendered options.\n *\n * If it is supplied (and not null/undefined), the rendered options will not\n * update in response to user actions. Instead, the `value` prop must change in\n * order for the rendered options to update.\n *\n * If `defaultValue` is provided, any options with the supplied values will be\n * selected.\n */\nvar ReactDOMSelect = ReactClass.createClass({\n displayName: 'ReactDOMSelect',\n tagName: 'SELECT',\n\n mixins: [AutoFocusMixin, LinkedValueUtils.Mixin, ReactBrowserComponentMixin],\n\n propTypes: {\n defaultValue: selectValueType,\n value: selectValueType\n },\n\n render: function() {\n // Clone `this.props` so we don't mutate the input.\n var props = assign({}, this.props);\n\n props.onChange = this._handleChange;\n props.value = null;\n\n return select(props, this.props.children);\n },\n\n componentWillMount: function() {\n this._pendingUpdate = false;\n },\n\n componentDidMount: function() {\n var value = LinkedValueUtils.getValue(this);\n if (value != null) {\n updateOptions(this, value);\n } else if (this.props.defaultValue != null) {\n updateOptions(this, this.props.defaultValue);\n }\n },\n\n componentDidUpdate: function(prevProps) {\n var value = LinkedValueUtils.getValue(this);\n if (value != null) {\n this._pendingUpdate = false;\n updateOptions(this, value);\n } else if (!prevProps.multiple !== !this.props.multiple) {\n // For simplicity, reapply `defaultValue` if `multiple` is toggled.\n if (this.props.defaultValue != null) {\n updateOptions(this, this.props.defaultValue);\n } else {\n // Revert the select back to its default unselected state.\n updateOptions(this, this.props.multiple ? [] : '');\n }\n }\n },\n\n _handleChange: function(event) {\n var returnValue;\n var onChange = LinkedValueUtils.getOnChange(this);\n if (onChange) {\n returnValue = onChange.call(this, event);\n }\n\n this._pendingUpdate = true;\n ReactUpdates.asap(updateOptionsIfPendingUpdateAndMounted, this);\n return returnValue;\n }\n\n});\n\nmodule.exports = ReactDOMSelect;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactDOMSelect.js\n ** module id = 184\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ReactDOMSelect.js?");
|
||
|
||
/***/ },
|
||
/* 185 */
|
||
/***/ 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 ReactDOMTextarea\n */\n\n'use strict';\n\nvar AutoFocusMixin = __webpack_require__(174);\nvar DOMPropertyOperations = __webpack_require__(126);\nvar LinkedValueUtils = __webpack_require__(181);\nvar ReactBrowserComponentMixin = __webpack_require__(170);\nvar ReactClass = __webpack_require__(120);\nvar ReactElement = __webpack_require__(79);\nvar ReactUpdates = __webpack_require__(101);\n\nvar assign = __webpack_require__(75);\nvar invariant = __webpack_require__(64);\n\nvar warning = __webpack_require__(82);\n\nvar textarea = ReactElement.createFactory('textarea');\n\nfunction forceUpdateIfMounted() {\n /*jshint validthis:true */\n if (this.isMounted()) {\n this.forceUpdate();\n }\n}\n\n/**\n * Implements a <textarea> native component that allows setting `value`, and\n * `defaultValue`. This differs from the traditional DOM API because value is\n * usually set as PCDATA children.\n *\n * If `value` is not supplied (or null/undefined), user actions that affect the\n * value will trigger updates to the element.\n *\n * If `value` is supplied (and not null/undefined), the rendered element will\n * not trigger updates to the element. Instead, the `value` prop must change in\n * order for the rendered element to be updated.\n *\n * The rendered element will be initialized with an empty value, the prop\n * `defaultValue` if specified, or the children content (deprecated).\n */\nvar ReactDOMTextarea = ReactClass.createClass({\n displayName: 'ReactDOMTextarea',\n tagName: 'TEXTAREA',\n\n mixins: [AutoFocusMixin, LinkedValueUtils.Mixin, ReactBrowserComponentMixin],\n\n getInitialState: function() {\n var defaultValue = this.props.defaultValue;\n // TODO (yungsters): Remove support for children content in <textarea>.\n var children = this.props.children;\n if (children != null) {\n if (\"production\" !== process.env.NODE_ENV) {\n (\"production\" !== process.env.NODE_ENV ? warning(\n false,\n 'Use the `defaultValue` or `value` props instead of setting ' +\n 'children on <textarea>.'\n ) : null);\n }\n (\"production\" !== process.env.NODE_ENV ? invariant(\n defaultValue == null,\n 'If you supply `defaultValue` on a <textarea>, do not pass children.'\n ) : invariant(defaultValue == null));\n if (Array.isArray(children)) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n children.length <= 1,\n '<textarea> can only have at most one child.'\n ) : invariant(children.length <= 1));\n children = children[0];\n }\n\n defaultValue = '' + children;\n }\n if (defaultValue == null) {\n defaultValue = '';\n }\n var value = LinkedValueUtils.getValue(this);\n return {\n // We save the initial value so that `ReactDOMComponent` doesn't update\n // `textContent` (unnecessary since we update value).\n // The initial value can be a boolean or object so that's why it's\n // forced to be a string.\n initialValue: '' + (value != null ? value : defaultValue)\n };\n },\n\n render: function() {\n // Clone `this.props` so we don't mutate the input.\n var props = assign({}, this.props);\n\n (\"production\" !== process.env.NODE_ENV ? invariant(\n props.dangerouslySetInnerHTML == null,\n '`dangerouslySetInnerHTML` does not make sense on <textarea>.'\n ) : invariant(props.dangerouslySetInnerHTML == null));\n\n props.defaultValue = null;\n props.value = null;\n props.onChange = this._handleChange;\n\n // Always set children to the same thing. In IE9, the selection range will\n // get reset if `textContent` is mutated.\n return textarea(props, this.state.initialValue);\n },\n\n componentDidUpdate: function(prevProps, prevState, prevContext) {\n var value = LinkedValueUtils.getValue(this);\n if (value != null) {\n var rootNode = this.getDOMNode();\n // Cast `value` to a string to ensure the value is set correctly. While\n // browsers typically do this as necessary, jsdom doesn't.\n DOMPropertyOperations.setValueForProperty(rootNode, 'value', '' + value);\n }\n },\n\n _handleChange: function(event) {\n var returnValue;\n var onChange = LinkedValueUtils.getOnChange(this);\n if (onChange) {\n returnValue = onChange.call(this, event);\n }\n ReactUpdates.asap(forceUpdateIfMounted, this);\n return returnValue;\n }\n\n});\n\nmodule.exports = ReactDOMTextarea;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactDOMTextarea.js\n ** module id = 185\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ReactDOMTextarea.js?");
|
||
|
||
/***/ },
|
||
/* 186 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\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 ReactEventListener\n * @typechecks static-only\n */\n\n'use strict';\n\nvar EventListener = __webpack_require__(187);\nvar ExecutionEnvironment = __webpack_require__(77);\nvar PooledClass = __webpack_require__(103);\nvar ReactInstanceHandles = __webpack_require__(92);\nvar ReactMount = __webpack_require__(61);\nvar ReactUpdates = __webpack_require__(101);\n\nvar assign = __webpack_require__(75);\nvar getEventTarget = __webpack_require__(158);\nvar getUnboundedScrollPosition = __webpack_require__(188);\n\n/**\n * Finds the parent React component of `node`.\n *\n * @param {*} node\n * @return {?DOMEventTarget} Parent container, or `null` if the specified node\n * is not nested.\n */\nfunction findParent(node) {\n // TODO: It may be a good idea to cache this to prevent unnecessary DOM\n // traversal, but caching is difficult to do correctly without using a\n // mutation observer to listen for all DOM changes.\n var nodeID = ReactMount.getID(node);\n var rootID = ReactInstanceHandles.getReactRootIDFromNodeID(nodeID);\n var container = ReactMount.findReactContainerForID(rootID);\n var parent = ReactMount.getFirstReactDOM(container);\n return parent;\n}\n\n// Used to store ancestor hierarchy in top level callback\nfunction TopLevelCallbackBookKeeping(topLevelType, nativeEvent) {\n this.topLevelType = topLevelType;\n this.nativeEvent = nativeEvent;\n this.ancestors = [];\n}\nassign(TopLevelCallbackBookKeeping.prototype, {\n destructor: function() {\n this.topLevelType = null;\n this.nativeEvent = null;\n this.ancestors.length = 0;\n }\n});\nPooledClass.addPoolingTo(\n TopLevelCallbackBookKeeping,\n PooledClass.twoArgumentPooler\n);\n\nfunction handleTopLevelImpl(bookKeeping) {\n var topLevelTarget = ReactMount.getFirstReactDOM(\n getEventTarget(bookKeeping.nativeEvent)\n ) || window;\n\n // Loop through the hierarchy, in case there's any nested components.\n // It's important that we build the array of ancestors before calling any\n // event handlers, because event handlers can modify the DOM, leading to\n // inconsistencies with ReactMount's node cache. See #1105.\n var ancestor = topLevelTarget;\n while (ancestor) {\n bookKeeping.ancestors.push(ancestor);\n ancestor = findParent(ancestor);\n }\n\n for (var i = 0, l = bookKeeping.ancestors.length; i < l; i++) {\n topLevelTarget = bookKeeping.ancestors[i];\n var topLevelTargetID = ReactMount.getID(topLevelTarget) || '';\n ReactEventListener._handleTopLevel(\n bookKeeping.topLevelType,\n topLevelTarget,\n topLevelTargetID,\n bookKeeping.nativeEvent\n );\n }\n}\n\nfunction scrollValueMonitor(cb) {\n var scrollPosition = getUnboundedScrollPosition(window);\n cb(scrollPosition);\n}\n\nvar ReactEventListener = {\n _enabled: true,\n _handleTopLevel: null,\n\n WINDOW_HANDLE: ExecutionEnvironment.canUseDOM ? window : null,\n\n setHandleTopLevel: function(handleTopLevel) {\n ReactEventListener._handleTopLevel = handleTopLevel;\n },\n\n setEnabled: function(enabled) {\n ReactEventListener._enabled = !!enabled;\n },\n\n isEnabled: function() {\n return ReactEventListener._enabled;\n },\n\n\n /**\n * Traps top-level events by using event bubbling.\n *\n * @param {string} topLevelType Record from `EventConstants`.\n * @param {string} handlerBaseName Event name (e.g. \"click\").\n * @param {object} handle Element on which to attach listener.\n * @return {object} An object with a remove function which will forcefully\n * remove the listener.\n * @internal\n */\n trapBubbledEvent: function(topLevelType, handlerBaseName, handle) {\n var element = handle;\n if (!element) {\n return null;\n }\n return EventListener.listen(\n element,\n handlerBaseName,\n ReactEventListener.dispatchEvent.bind(null, topLevelType)\n );\n },\n\n /**\n * Traps a top-level event by using event capturing.\n *\n * @param {string} topLevelType Record from `EventConstants`.\n * @param {string} handlerBaseName Event name (e.g. \"click\").\n * @param {object} handle Element on which to attach listener.\n * @return {object} An object with a remove function which will forcefully\n * remove the listener.\n * @internal\n */\n trapCapturedEvent: function(topLevelType, handlerBaseName, handle) {\n var element = handle;\n if (!element) {\n return null;\n }\n return EventListener.capture(\n element,\n handlerBaseName,\n ReactEventListener.dispatchEvent.bind(null, topLevelType)\n );\n },\n\n monitorScrollValue: function(refresh) {\n var callback = scrollValueMonitor.bind(null, refresh);\n EventListener.listen(window, 'scroll', callback);\n },\n\n dispatchEvent: function(topLevelType, nativeEvent) {\n if (!ReactEventListener._enabled) {\n return;\n }\n\n var bookKeeping = TopLevelCallbackBookKeeping.getPooled(\n topLevelType,\n nativeEvent\n );\n try {\n // Event queue being processed in the same cycle allows\n // `preventDefault`.\n ReactUpdates.batchedUpdates(handleTopLevelImpl, bookKeeping);\n } finally {\n TopLevelCallbackBookKeeping.release(bookKeeping);\n }\n }\n};\n\nmodule.exports = ReactEventListener;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactEventListener.js\n ** module id = 186\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ReactEventListener.js?");
|
||
|
||
/***/ },
|
||
/* 187 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/* WEBPACK VAR INJECTION */(function(process) {/**\n * Copyright 2013-2015, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n *\n * @providesModule EventListener\n * @typechecks\n */\n\nvar emptyFunction = __webpack_require__(83);\n\n/**\n * Upstream version of event listener. Does not take into account specific\n * nature of platform.\n */\nvar EventListener = {\n /**\n * Listen to DOM events during the bubble phase.\n *\n * @param {DOMEventTarget} target DOM element to register listener on.\n * @param {string} eventType Event type, e.g. 'click' or 'mouseover'.\n * @param {function} callback Callback function.\n * @return {object} Object with a `remove` method.\n */\n listen: function(target, eventType, callback) {\n if (target.addEventListener) {\n target.addEventListener(eventType, callback, false);\n return {\n remove: function() {\n target.removeEventListener(eventType, callback, false);\n }\n };\n } else if (target.attachEvent) {\n target.attachEvent('on' + eventType, callback);\n return {\n remove: function() {\n target.detachEvent('on' + eventType, callback);\n }\n };\n }\n },\n\n /**\n * Listen to DOM events during the capture phase.\n *\n * @param {DOMEventTarget} target DOM element to register listener on.\n * @param {string} eventType Event type, e.g. 'click' or 'mouseover'.\n * @param {function} callback Callback function.\n * @return {object} Object with a `remove` method.\n */\n capture: function(target, eventType, callback) {\n if (!target.addEventListener) {\n if (\"production\" !== process.env.NODE_ENV) {\n console.error(\n 'Attempted to listen to events during the capture phase on a ' +\n 'browser that does not support the capture phase. Your application ' +\n 'will not receive some events.'\n );\n }\n return {\n remove: emptyFunction\n };\n } else {\n target.addEventListener(eventType, callback, true);\n return {\n remove: function() {\n target.removeEventListener(eventType, callback, true);\n }\n };\n }\n },\n\n registerDefault: function() {}\n};\n\nmodule.exports = EventListener;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/EventListener.js\n ** module id = 187\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/EventListener.js?");
|
||
|
||
/***/ },
|
||
/* 188 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("/**\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 getUnboundedScrollPosition\n * @typechecks\n */\n\n\"use strict\";\n\n/**\n * Gets the scroll position of the supplied element or window.\n *\n * The return values are unbounded, unlike `getScrollPosition`. This means they\n * may be negative or exceed the element boundaries (which is possible using\n * inertial scrolling).\n *\n * @param {DOMWindow|DOMElement} scrollable\n * @return {object} Map with `x` and `y` keys.\n */\nfunction getUnboundedScrollPosition(scrollable) {\n if (scrollable === window) {\n return {\n x: window.pageXOffset || document.documentElement.scrollLeft,\n y: window.pageYOffset || document.documentElement.scrollTop\n };\n }\n return {\n x: scrollable.scrollLeft,\n y: scrollable.scrollTop\n };\n}\n\nmodule.exports = getUnboundedScrollPosition;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/getUnboundedScrollPosition.js\n ** module id = 188\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/getUnboundedScrollPosition.js?");
|
||
|
||
/***/ },
|
||
/* 189 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\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 ReactInjection\n */\n\n'use strict';\n\nvar DOMProperty = __webpack_require__(63);\nvar EventPluginHub = __webpack_require__(68);\nvar ReactComponentEnvironment = __webpack_require__(112);\nvar ReactClass = __webpack_require__(120);\nvar ReactEmptyComponent = __webpack_require__(90);\nvar ReactBrowserEventEmitter = __webpack_require__(65);\nvar ReactNativeComponent = __webpack_require__(88);\nvar ReactDOMComponent = __webpack_require__(147);\nvar ReactPerf = __webpack_require__(96);\nvar ReactRootIndex = __webpack_require__(93);\nvar ReactUpdates = __webpack_require__(101);\n\nvar ReactInjection = {\n Component: ReactComponentEnvironment.injection,\n Class: ReactClass.injection,\n DOMComponent: ReactDOMComponent.injection,\n DOMProperty: DOMProperty.injection,\n EmptyComponent: ReactEmptyComponent.injection,\n EventPluginHub: EventPluginHub.injection,\n EventEmitter: ReactBrowserEventEmitter.injection,\n NativeComponent: ReactNativeComponent.injection,\n Perf: ReactPerf.injection,\n RootIndex: ReactRootIndex.injection,\n Updates: ReactUpdates.injection\n};\n\nmodule.exports = ReactInjection;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactInjection.js\n ** module id = 189\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ReactInjection.js?");
|
||
|
||
/***/ },
|
||
/* 190 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\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 ReactReconcileTransaction\n * @typechecks static-only\n */\n\n'use strict';\n\nvar CallbackQueue = __webpack_require__(102);\nvar PooledClass = __webpack_require__(103);\nvar ReactBrowserEventEmitter = __webpack_require__(65);\nvar ReactInputSelection = __webpack_require__(191);\nvar ReactPutListenerQueue = __webpack_require__(195);\nvar Transaction = __webpack_require__(104);\n\nvar assign = __webpack_require__(75);\n\n/**\n * Ensures that, when possible, the selection range (currently selected text\n * input) is not disturbed by performing the transaction.\n */\nvar SELECTION_RESTORATION = {\n /**\n * @return {Selection} Selection information.\n */\n initialize: ReactInputSelection.getSelectionInformation,\n /**\n * @param {Selection} sel Selection information returned from `initialize`.\n */\n close: ReactInputSelection.restoreSelection\n};\n\n/**\n * Suppresses events (blur/focus) that could be inadvertently dispatched due to\n * high level DOM manipulations (like temporarily removing a text input from the\n * DOM).\n */\nvar EVENT_SUPPRESSION = {\n /**\n * @return {boolean} The enabled status of `ReactBrowserEventEmitter` before\n * the reconciliation.\n */\n initialize: function() {\n var currentlyEnabled = ReactBrowserEventEmitter.isEnabled();\n ReactBrowserEventEmitter.setEnabled(false);\n return currentlyEnabled;\n },\n\n /**\n * @param {boolean} previouslyEnabled Enabled status of\n * `ReactBrowserEventEmitter` before the reconciliation occured. `close`\n * restores the previous value.\n */\n close: function(previouslyEnabled) {\n ReactBrowserEventEmitter.setEnabled(previouslyEnabled);\n }\n};\n\n/**\n * Provides a queue for collecting `componentDidMount` and\n * `componentDidUpdate` callbacks during the the transaction.\n */\nvar ON_DOM_READY_QUEUEING = {\n /**\n * Initializes the internal `onDOMReady` queue.\n */\n initialize: function() {\n this.reactMountReady.reset();\n },\n\n /**\n * After DOM is flushed, invoke all registered `onDOMReady` callbacks.\n */\n close: function() {\n this.reactMountReady.notifyAll();\n }\n};\n\nvar PUT_LISTENER_QUEUEING = {\n initialize: function() {\n this.putListenerQueue.reset();\n },\n\n close: function() {\n this.putListenerQueue.putListeners();\n }\n};\n\n/**\n * Executed within the scope of the `Transaction` instance. Consider these as\n * being member methods, but with an implied ordering while being isolated from\n * each other.\n */\nvar TRANSACTION_WRAPPERS = [\n PUT_LISTENER_QUEUEING,\n SELECTION_RESTORATION,\n EVENT_SUPPRESSION,\n ON_DOM_READY_QUEUEING\n];\n\n/**\n * Currently:\n * - The order that these are listed in the transaction is critical:\n * - Suppresses events.\n * - Restores selection range.\n *\n * Future:\n * - Restore document/overflow scroll positions that were unintentionally\n * modified via DOM insertions above the top viewport boundary.\n * - Implement/integrate with customized constraint based layout system and keep\n * track of which dimensions must be remeasured.\n *\n * @class ReactReconcileTransaction\n */\nfunction ReactReconcileTransaction() {\n this.reinitializeTransaction();\n // Only server-side rendering really needs this option (see\n // `ReactServerRendering`), but server-side uses\n // `ReactServerRenderingTransaction` instead. This option is here so that it's\n // accessible and defaults to false when `ReactDOMComponent` and\n // `ReactTextComponent` checks it in `mountComponent`.`\n this.renderToStaticMarkup = false;\n this.reactMountReady = CallbackQueue.getPooled(null);\n this.putListenerQueue = ReactPutListenerQueue.getPooled();\n}\n\nvar Mixin = {\n /**\n * @see Transaction\n * @abstract\n * @final\n * @return {array<object>} List of operation wrap proceedures.\n * TODO: convert to array<TransactionWrapper>\n */\n getTransactionWrappers: function() {\n return TRANSACTION_WRAPPERS;\n },\n\n /**\n * @return {object} The queue to collect `onDOMReady` callbacks with.\n */\n getReactMountReady: function() {\n return this.reactMountReady;\n },\n\n getPutListenerQueue: function() {\n return this.putListenerQueue;\n },\n\n /**\n * `PooledClass` looks for this, and will invoke this before allowing this\n * instance to be resused.\n */\n destructor: function() {\n CallbackQueue.release(this.reactMountReady);\n this.reactMountReady = null;\n\n ReactPutListenerQueue.release(this.putListenerQueue);\n this.putListenerQueue = null;\n }\n};\n\n\nassign(ReactReconcileTransaction.prototype, Transaction.Mixin, Mixin);\n\nPooledClass.addPoolingTo(ReactReconcileTransaction);\n\nmodule.exports = ReactReconcileTransaction;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactReconcileTransaction.js\n ** module id = 190\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ReactReconcileTransaction.js?");
|
||
|
||
/***/ },
|
||
/* 191 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\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 ReactInputSelection\n */\n\n'use strict';\n\nvar ReactDOMSelection = __webpack_require__(192);\n\nvar containsNode = __webpack_require__(106);\nvar focusNode = __webpack_require__(175);\nvar getActiveElement = __webpack_require__(194);\n\nfunction isInDocument(node) {\n return containsNode(document.documentElement, node);\n}\n\n/**\n * @ReactInputSelection: React input selection module. Based on Selection.js,\n * but modified to be suitable for react and has a couple of bug fixes (doesn't\n * assume buttons have range selections allowed).\n * Input selection module for React.\n */\nvar ReactInputSelection = {\n\n hasSelectionCapabilities: function(elem) {\n return elem && (\n ((elem.nodeName === 'INPUT' && elem.type === 'text') ||\n elem.nodeName === 'TEXTAREA' || elem.contentEditable === 'true')\n );\n },\n\n getSelectionInformation: function() {\n var focusedElem = getActiveElement();\n return {\n focusedElem: focusedElem,\n selectionRange:\n ReactInputSelection.hasSelectionCapabilities(focusedElem) ?\n ReactInputSelection.getSelection(focusedElem) :\n null\n };\n },\n\n /**\n * @restoreSelection: If any selection information was potentially lost,\n * restore it. This is useful when performing operations that could remove dom\n * nodes and place them back in, resulting in focus being lost.\n */\n restoreSelection: function(priorSelectionInformation) {\n var curFocusedElem = getActiveElement();\n var priorFocusedElem = priorSelectionInformation.focusedElem;\n var priorSelectionRange = priorSelectionInformation.selectionRange;\n if (curFocusedElem !== priorFocusedElem &&\n isInDocument(priorFocusedElem)) {\n if (ReactInputSelection.hasSelectionCapabilities(priorFocusedElem)) {\n ReactInputSelection.setSelection(\n priorFocusedElem,\n priorSelectionRange\n );\n }\n focusNode(priorFocusedElem);\n }\n },\n\n /**\n * @getSelection: Gets the selection bounds of a focused textarea, input or\n * contentEditable node.\n * -@input: Look up selection bounds of this input\n * -@return {start: selectionStart, end: selectionEnd}\n */\n getSelection: function(input) {\n var selection;\n\n if ('selectionStart' in input) {\n // Modern browser with input or textarea.\n selection = {\n start: input.selectionStart,\n end: input.selectionEnd\n };\n } else if (document.selection && input.nodeName === 'INPUT') {\n // IE8 input.\n var range = document.selection.createRange();\n // There can only be one selection per document in IE, so it must\n // be in our element.\n if (range.parentElement() === input) {\n selection = {\n start: -range.moveStart('character', -input.value.length),\n end: -range.moveEnd('character', -input.value.length)\n };\n }\n } else {\n // Content editable or old IE textarea.\n selection = ReactDOMSelection.getOffsets(input);\n }\n\n return selection || {start: 0, end: 0};\n },\n\n /**\n * @setSelection: Sets the selection bounds of a textarea or input and focuses\n * the input.\n * -@input Set selection bounds of this input or textarea\n * -@offsets Object of same form that is returned from get*\n */\n setSelection: function(input, offsets) {\n var start = offsets.start;\n var end = offsets.end;\n if (typeof end === 'undefined') {\n end = start;\n }\n\n if ('selectionStart' in input) {\n input.selectionStart = start;\n input.selectionEnd = Math.min(end, input.value.length);\n } else if (document.selection && input.nodeName === 'INPUT') {\n var range = input.createTextRange();\n range.collapse(true);\n range.moveStart('character', start);\n range.moveEnd('character', end - start);\n range.select();\n } else {\n ReactDOMSelection.setOffsets(input, offsets);\n }\n }\n};\n\nmodule.exports = ReactInputSelection;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactInputSelection.js\n ** module id = 191\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ReactInputSelection.js?");
|
||
|
||
/***/ },
|
||
/* 192 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\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 ReactDOMSelection\n */\n\n'use strict';\n\nvar ExecutionEnvironment = __webpack_require__(77);\n\nvar getNodeForCharacterOffset = __webpack_require__(193);\nvar getTextContentAccessor = __webpack_require__(155);\n\n/**\n * While `isCollapsed` is available on the Selection object and `collapsed`\n * is available on the Range object, IE11 sometimes gets them wrong.\n * If the anchor/focus nodes and offsets are the same, the range is collapsed.\n */\nfunction isCollapsed(anchorNode, anchorOffset, focusNode, focusOffset) {\n return anchorNode === focusNode && anchorOffset === focusOffset;\n}\n\n/**\n * Get the appropriate anchor and focus node/offset pairs for IE.\n *\n * The catch here is that IE's selection API doesn't provide information\n * about whether the selection is forward or backward, so we have to\n * behave as though it's always forward.\n *\n * IE text differs from modern selection in that it behaves as though\n * block elements end with a new line. This means character offsets will\n * differ between the two APIs.\n *\n * @param {DOMElement} node\n * @return {object}\n */\nfunction getIEOffsets(node) {\n var selection = document.selection;\n var selectedRange = selection.createRange();\n var selectedLength = selectedRange.text.length;\n\n // Duplicate selection so we can move range without breaking user selection.\n var fromStart = selectedRange.duplicate();\n fromStart.moveToElementText(node);\n fromStart.setEndPoint('EndToStart', selectedRange);\n\n var startOffset = fromStart.text.length;\n var endOffset = startOffset + selectedLength;\n\n return {\n start: startOffset,\n end: endOffset\n };\n}\n\n/**\n * @param {DOMElement} node\n * @return {?object}\n */\nfunction getModernOffsets(node) {\n var selection = window.getSelection && window.getSelection();\n\n if (!selection || selection.rangeCount === 0) {\n return null;\n }\n\n var anchorNode = selection.anchorNode;\n var anchorOffset = selection.anchorOffset;\n var focusNode = selection.focusNode;\n var focusOffset = selection.focusOffset;\n\n var currentRange = selection.getRangeAt(0);\n\n // If the node and offset values are the same, the selection is collapsed.\n // `Selection.isCollapsed` is available natively, but IE sometimes gets\n // this value wrong.\n var isSelectionCollapsed = isCollapsed(\n selection.anchorNode,\n selection.anchorOffset,\n selection.focusNode,\n selection.focusOffset\n );\n\n var rangeLength = isSelectionCollapsed ? 0 : currentRange.toString().length;\n\n var tempRange = currentRange.cloneRange();\n tempRange.selectNodeContents(node);\n tempRange.setEnd(currentRange.startContainer, currentRange.startOffset);\n\n var isTempRangeCollapsed = isCollapsed(\n tempRange.startContainer,\n tempRange.startOffset,\n tempRange.endContainer,\n tempRange.endOffset\n );\n\n var start = isTempRangeCollapsed ? 0 : tempRange.toString().length;\n var end = start + rangeLength;\n\n // Detect whether the selection is backward.\n var detectionRange = document.createRange();\n detectionRange.setStart(anchorNode, anchorOffset);\n detectionRange.setEnd(focusNode, focusOffset);\n var isBackward = detectionRange.collapsed;\n\n return {\n start: isBackward ? end : start,\n end: isBackward ? start : end\n };\n}\n\n/**\n * @param {DOMElement|DOMTextNode} node\n * @param {object} offsets\n */\nfunction setIEOffsets(node, offsets) {\n var range = document.selection.createRange().duplicate();\n var start, end;\n\n if (typeof offsets.end === 'undefined') {\n start = offsets.start;\n end = start;\n } else if (offsets.start > offsets.end) {\n start = offsets.end;\n end = offsets.start;\n } else {\n start = offsets.start;\n end = offsets.end;\n }\n\n range.moveToElementText(node);\n range.moveStart('character', start);\n range.setEndPoint('EndToStart', range);\n range.moveEnd('character', end - start);\n range.select();\n}\n\n/**\n * In modern non-IE browsers, we can support both forward and backward\n * selections.\n *\n * Note: IE10+ supports the Selection object, but it does not support\n * the `extend` method, which means that even in modern IE, it's not possible\n * to programatically create a backward selection. Thus, for all IE\n * versions, we use the old IE API to create our selections.\n *\n * @param {DOMElement|DOMTextNode} node\n * @param {object} offsets\n */\nfunction setModernOffsets(node, offsets) {\n if (!window.getSelection) {\n return;\n }\n\n var selection = window.getSelection();\n var length = node[getTextContentAccessor()].length;\n var start = Math.min(offsets.start, length);\n var end = typeof offsets.end === 'undefined' ?\n start : Math.min(offsets.end, length);\n\n // IE 11 uses modern selection, but doesn't support the extend method.\n // Flip backward selections, so we can set with a single range.\n if (!selection.extend && start > end) {\n var temp = end;\n end = start;\n start = temp;\n }\n\n var startMarker = getNodeForCharacterOffset(node, start);\n var endMarker = getNodeForCharacterOffset(node, end);\n\n if (startMarker && endMarker) {\n var range = document.createRange();\n range.setStart(startMarker.node, startMarker.offset);\n selection.removeAllRanges();\n\n if (start > end) {\n selection.addRange(range);\n selection.extend(endMarker.node, endMarker.offset);\n } else {\n range.setEnd(endMarker.node, endMarker.offset);\n selection.addRange(range);\n }\n }\n}\n\nvar useIEOffsets = (\n ExecutionEnvironment.canUseDOM &&\n 'selection' in document &&\n !('getSelection' in window)\n);\n\nvar ReactDOMSelection = {\n /**\n * @param {DOMElement} node\n */\n getOffsets: useIEOffsets ? getIEOffsets : getModernOffsets,\n\n /**\n * @param {DOMElement|DOMTextNode} node\n * @param {object} offsets\n */\n setOffsets: useIEOffsets ? setIEOffsets : setModernOffsets\n};\n\nmodule.exports = ReactDOMSelection;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactDOMSelection.js\n ** module id = 192\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ReactDOMSelection.js?");
|
||
|
||
/***/ },
|
||
/* 193 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("/**\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 getNodeForCharacterOffset\n */\n\n'use strict';\n\n/**\n * Given any node return the first leaf node without children.\n *\n * @param {DOMElement|DOMTextNode} node\n * @return {DOMElement|DOMTextNode}\n */\nfunction getLeafNode(node) {\n while (node && node.firstChild) {\n node = node.firstChild;\n }\n return node;\n}\n\n/**\n * Get the next sibling within a container. This will walk up the\n * DOM if a node's siblings have been exhausted.\n *\n * @param {DOMElement|DOMTextNode} node\n * @return {?DOMElement|DOMTextNode}\n */\nfunction getSiblingNode(node) {\n while (node) {\n if (node.nextSibling) {\n return node.nextSibling;\n }\n node = node.parentNode;\n }\n}\n\n/**\n * Get object describing the nodes which contain characters at offset.\n *\n * @param {DOMElement|DOMTextNode} root\n * @param {number} offset\n * @return {?object}\n */\nfunction getNodeForCharacterOffset(root, offset) {\n var node = getLeafNode(root);\n var nodeStart = 0;\n var nodeEnd = 0;\n\n while (node) {\n if (node.nodeType === 3) {\n nodeEnd = nodeStart + node.textContent.length;\n\n if (nodeStart <= offset && nodeEnd >= offset) {\n return {\n node: node,\n offset: offset - nodeStart\n };\n }\n\n nodeStart = nodeEnd;\n }\n\n node = getLeafNode(getSiblingNode(node));\n }\n}\n\nmodule.exports = getNodeForCharacterOffset;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/getNodeForCharacterOffset.js\n ** module id = 193\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/getNodeForCharacterOffset.js?");
|
||
|
||
/***/ },
|
||
/* 194 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("/**\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 getActiveElement\n * @typechecks\n */\n\n/**\n * Same as document.activeElement but wraps in a try-catch block. In IE it is\n * not safe to call document.activeElement if there is nothing focused.\n *\n * The activeElement will be null only if the document body is not yet defined.\n */\nfunction getActiveElement() /*?DOMElement*/ {\n try {\n return document.activeElement || document.body;\n } catch (e) {\n return document.body;\n }\n}\n\nmodule.exports = getActiveElement;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/getActiveElement.js\n ** module id = 194\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/getActiveElement.js?");
|
||
|
||
/***/ },
|
||
/* 195 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\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 ReactPutListenerQueue\n */\n\n'use strict';\n\nvar PooledClass = __webpack_require__(103);\nvar ReactBrowserEventEmitter = __webpack_require__(65);\n\nvar assign = __webpack_require__(75);\n\nfunction ReactPutListenerQueue() {\n this.listenersToPut = [];\n}\n\nassign(ReactPutListenerQueue.prototype, {\n enqueuePutListener: function(rootNodeID, propKey, propValue) {\n this.listenersToPut.push({\n rootNodeID: rootNodeID,\n propKey: propKey,\n propValue: propValue\n });\n },\n\n putListeners: function() {\n for (var i = 0; i < this.listenersToPut.length; i++) {\n var listenerToPut = this.listenersToPut[i];\n ReactBrowserEventEmitter.putListener(\n listenerToPut.rootNodeID,\n listenerToPut.propKey,\n listenerToPut.propValue\n );\n }\n },\n\n reset: function() {\n this.listenersToPut.length = 0;\n },\n\n destructor: function() {\n this.reset();\n }\n});\n\nPooledClass.addPoolingTo(ReactPutListenerQueue);\n\nmodule.exports = ReactPutListenerQueue;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactPutListenerQueue.js\n ** module id = 195\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ReactPutListenerQueue.js?");
|
||
|
||
/***/ },
|
||
/* 196 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\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 SelectEventPlugin\n */\n\n'use strict';\n\nvar EventConstants = __webpack_require__(66);\nvar EventPropagators = __webpack_require__(153);\nvar ReactInputSelection = __webpack_require__(191);\nvar SyntheticEvent = __webpack_require__(157);\n\nvar getActiveElement = __webpack_require__(194);\nvar isTextInputElement = __webpack_require__(161);\nvar keyOf = __webpack_require__(122);\nvar shallowEqual = __webpack_require__(197);\n\nvar topLevelTypes = EventConstants.topLevelTypes;\n\nvar eventTypes = {\n select: {\n phasedRegistrationNames: {\n bubbled: keyOf({onSelect: null}),\n captured: keyOf({onSelectCapture: null})\n },\n dependencies: [\n topLevelTypes.topBlur,\n topLevelTypes.topContextMenu,\n topLevelTypes.topFocus,\n topLevelTypes.topKeyDown,\n topLevelTypes.topMouseDown,\n topLevelTypes.topMouseUp,\n topLevelTypes.topSelectionChange\n ]\n }\n};\n\nvar activeElement = null;\nvar activeElementID = null;\nvar lastSelection = null;\nvar mouseDown = false;\n\n/**\n * Get an object which is a unique representation of the current selection.\n *\n * The return value will not be consistent across nodes or browsers, but\n * two identical selections on the same node will return identical objects.\n *\n * @param {DOMElement} node\n * @param {object}\n */\nfunction getSelection(node) {\n if ('selectionStart' in node &&\n ReactInputSelection.hasSelectionCapabilities(node)) {\n return {\n start: node.selectionStart,\n end: node.selectionEnd\n };\n } else if (window.getSelection) {\n var selection = window.getSelection();\n return {\n anchorNode: selection.anchorNode,\n anchorOffset: selection.anchorOffset,\n focusNode: selection.focusNode,\n focusOffset: selection.focusOffset\n };\n } else if (document.selection) {\n var range = document.selection.createRange();\n return {\n parentElement: range.parentElement(),\n text: range.text,\n top: range.boundingTop,\n left: range.boundingLeft\n };\n }\n}\n\n/**\n * Poll selection to see whether it's changed.\n *\n * @param {object} nativeEvent\n * @return {?SyntheticEvent}\n */\nfunction constructSelectEvent(nativeEvent) {\n // Ensure we have the right element, and that the user is not dragging a\n // selection (this matches native `select` event behavior). In HTML5, select\n // fires only on input and textarea thus if there's no focused element we\n // won't dispatch.\n if (mouseDown ||\n activeElement == null ||\n activeElement !== getActiveElement()) {\n return null;\n }\n\n // Only fire when selection has actually changed.\n var currentSelection = getSelection(activeElement);\n if (!lastSelection || !shallowEqual(lastSelection, currentSelection)) {\n lastSelection = currentSelection;\n\n var syntheticEvent = SyntheticEvent.getPooled(\n eventTypes.select,\n activeElementID,\n nativeEvent\n );\n\n syntheticEvent.type = 'select';\n syntheticEvent.target = activeElement;\n\n EventPropagators.accumulateTwoPhaseDispatches(syntheticEvent);\n\n return syntheticEvent;\n }\n}\n\n/**\n * This plugin creates an `onSelect` event that normalizes select events\n * across form elements.\n *\n * Supported elements are:\n * - input (see `isTextInputElement`)\n * - textarea\n * - contentEditable\n *\n * This differs from native browser implementations in the following ways:\n * - Fires on contentEditable fields as well as inputs.\n * - Fires for collapsed selection.\n * - Fires after user input.\n */\nvar SelectEventPlugin = {\n\n eventTypes: eventTypes,\n\n /**\n * @param {string} topLevelType Record from `EventConstants`.\n * @param {DOMEventTarget} topLevelTarget The listening component root node.\n * @param {string} topLevelTargetID ID of `topLevelTarget`.\n * @param {object} nativeEvent Native browser event.\n * @return {*} An accumulation of synthetic events.\n * @see {EventPluginHub.extractEvents}\n */\n extractEvents: function(\n topLevelType,\n topLevelTarget,\n topLevelTargetID,\n nativeEvent) {\n\n switch (topLevelType) {\n // Track the input node that has focus.\n case topLevelTypes.topFocus:\n if (isTextInputElement(topLevelTarget) ||\n topLevelTarget.contentEditable === 'true') {\n activeElement = topLevelTarget;\n activeElementID = topLevelTargetID;\n lastSelection = null;\n }\n break;\n case topLevelTypes.topBlur:\n activeElement = null;\n activeElementID = null;\n lastSelection = null;\n break;\n\n // Don't fire the event while the user is dragging. This matches the\n // semantics of the native select event.\n case topLevelTypes.topMouseDown:\n mouseDown = true;\n break;\n case topLevelTypes.topContextMenu:\n case topLevelTypes.topMouseUp:\n mouseDown = false;\n return constructSelectEvent(nativeEvent);\n\n // Chrome and IE fire non-standard event when selection is changed (and\n // sometimes when it hasn't).\n // Firefox doesn't support selectionchange, so check selection status\n // after each key entry. The selection changes after keydown and before\n // keyup, but we check on keydown as well in the case of holding down a\n // key, when multiple keydown events are fired but only one keyup is.\n case topLevelTypes.topSelectionChange:\n case topLevelTypes.topKeyDown:\n case topLevelTypes.topKeyUp:\n return constructSelectEvent(nativeEvent);\n }\n }\n};\n\nmodule.exports = SelectEventPlugin;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/SelectEventPlugin.js\n ** module id = 196\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/SelectEventPlugin.js?");
|
||
|
||
/***/ },
|
||
/* 197 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("/**\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 shallowEqual\n */\n\n'use strict';\n\n/**\n * Performs equality by iterating through keys on an object and returning\n * false when any key has values which are not strictly equal between\n * objA and objB. Returns true when the values of all keys are strictly equal.\n *\n * @return {boolean}\n */\nfunction shallowEqual(objA, objB) {\n if (objA === objB) {\n return true;\n }\n var key;\n // Test for A's keys different from B.\n for (key in objA) {\n if (objA.hasOwnProperty(key) &&\n (!objB.hasOwnProperty(key) || objA[key] !== objB[key])) {\n return false;\n }\n }\n // Test for B's keys missing from A.\n for (key in objB) {\n if (objB.hasOwnProperty(key) && !objA.hasOwnProperty(key)) {\n return false;\n }\n }\n return true;\n}\n\nmodule.exports = shallowEqual;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/shallowEqual.js\n ** module id = 197\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/shallowEqual.js?");
|
||
|
||
/***/ },
|
||
/* 198 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("/**\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 ServerReactRootIndex\n * @typechecks\n */\n\n'use strict';\n\n/**\n * Size of the reactRoot ID space. We generate random numbers for React root\n * IDs and if there's a collision the events and DOM update system will\n * get confused. In the future we need a way to generate GUIDs but for\n * now this will work on a smaller scale.\n */\nvar GLOBAL_MOUNT_POINT_MAX = Math.pow(2, 53);\n\nvar ServerReactRootIndex = {\n createReactRootIndex: function() {\n return Math.ceil(Math.random() * GLOBAL_MOUNT_POINT_MAX);\n }\n};\n\nmodule.exports = ServerReactRootIndex;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ServerReactRootIndex.js\n ** module id = 198\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ServerReactRootIndex.js?");
|
||
|
||
/***/ },
|
||
/* 199 */
|
||
/***/ 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 SimpleEventPlugin\n */\n\n'use strict';\n\nvar EventConstants = __webpack_require__(66);\nvar EventPluginUtils = __webpack_require__(70);\nvar EventPropagators = __webpack_require__(153);\nvar SyntheticClipboardEvent = __webpack_require__(201);\nvar SyntheticEvent = __webpack_require__(157);\nvar SyntheticFocusEvent = __webpack_require__(202);\nvar SyntheticKeyboardEvent = __webpack_require__(203);\nvar SyntheticMouseEvent = __webpack_require__(165);\nvar SyntheticDragEvent = __webpack_require__(200);\nvar SyntheticTouchEvent = __webpack_require__(206);\nvar SyntheticUIEvent = __webpack_require__(166);\nvar SyntheticWheelEvent = __webpack_require__(207);\n\nvar getEventCharCode = __webpack_require__(204);\n\nvar invariant = __webpack_require__(64);\nvar keyOf = __webpack_require__(122);\nvar warning = __webpack_require__(82);\n\nvar topLevelTypes = EventConstants.topLevelTypes;\n\nvar eventTypes = {\n blur: {\n phasedRegistrationNames: {\n bubbled: keyOf({onBlur: true}),\n captured: keyOf({onBlurCapture: true})\n }\n },\n click: {\n phasedRegistrationNames: {\n bubbled: keyOf({onClick: true}),\n captured: keyOf({onClickCapture: true})\n }\n },\n contextMenu: {\n phasedRegistrationNames: {\n bubbled: keyOf({onContextMenu: true}),\n captured: keyOf({onContextMenuCapture: true})\n }\n },\n copy: {\n phasedRegistrationNames: {\n bubbled: keyOf({onCopy: true}),\n captured: keyOf({onCopyCapture: true})\n }\n },\n cut: {\n phasedRegistrationNames: {\n bubbled: keyOf({onCut: true}),\n captured: keyOf({onCutCapture: true})\n }\n },\n doubleClick: {\n phasedRegistrationNames: {\n bubbled: keyOf({onDoubleClick: true}),\n captured: keyOf({onDoubleClickCapture: true})\n }\n },\n drag: {\n phasedRegistrationNames: {\n bubbled: keyOf({onDrag: true}),\n captured: keyOf({onDragCapture: true})\n }\n },\n dragEnd: {\n phasedRegistrationNames: {\n bubbled: keyOf({onDragEnd: true}),\n captured: keyOf({onDragEndCapture: true})\n }\n },\n dragEnter: {\n phasedRegistrationNames: {\n bubbled: keyOf({onDragEnter: true}),\n captured: keyOf({onDragEnterCapture: true})\n }\n },\n dragExit: {\n phasedRegistrationNames: {\n bubbled: keyOf({onDragExit: true}),\n captured: keyOf({onDragExitCapture: true})\n }\n },\n dragLeave: {\n phasedRegistrationNames: {\n bubbled: keyOf({onDragLeave: true}),\n captured: keyOf({onDragLeaveCapture: true})\n }\n },\n dragOver: {\n phasedRegistrationNames: {\n bubbled: keyOf({onDragOver: true}),\n captured: keyOf({onDragOverCapture: true})\n }\n },\n dragStart: {\n phasedRegistrationNames: {\n bubbled: keyOf({onDragStart: true}),\n captured: keyOf({onDragStartCapture: true})\n }\n },\n drop: {\n phasedRegistrationNames: {\n bubbled: keyOf({onDrop: true}),\n captured: keyOf({onDropCapture: true})\n }\n },\n focus: {\n phasedRegistrationNames: {\n bubbled: keyOf({onFocus: true}),\n captured: keyOf({onFocusCapture: true})\n }\n },\n input: {\n phasedRegistrationNames: {\n bubbled: keyOf({onInput: true}),\n captured: keyOf({onInputCapture: true})\n }\n },\n keyDown: {\n phasedRegistrationNames: {\n bubbled: keyOf({onKeyDown: true}),\n captured: keyOf({onKeyDownCapture: true})\n }\n },\n keyPress: {\n phasedRegistrationNames: {\n bubbled: keyOf({onKeyPress: true}),\n captured: keyOf({onKeyPressCapture: true})\n }\n },\n keyUp: {\n phasedRegistrationNames: {\n bubbled: keyOf({onKeyUp: true}),\n captured: keyOf({onKeyUpCapture: true})\n }\n },\n load: {\n phasedRegistrationNames: {\n bubbled: keyOf({onLoad: true}),\n captured: keyOf({onLoadCapture: true})\n }\n },\n error: {\n phasedRegistrationNames: {\n bubbled: keyOf({onError: true}),\n captured: keyOf({onErrorCapture: true})\n }\n },\n // Note: We do not allow listening to mouseOver events. Instead, use the\n // onMouseEnter/onMouseLeave created by `EnterLeaveEventPlugin`.\n mouseDown: {\n phasedRegistrationNames: {\n bubbled: keyOf({onMouseDown: true}),\n captured: keyOf({onMouseDownCapture: true})\n }\n },\n mouseMove: {\n phasedRegistrationNames: {\n bubbled: keyOf({onMouseMove: true}),\n captured: keyOf({onMouseMoveCapture: true})\n }\n },\n mouseOut: {\n phasedRegistrationNames: {\n bubbled: keyOf({onMouseOut: true}),\n captured: keyOf({onMouseOutCapture: true})\n }\n },\n mouseOver: {\n phasedRegistrationNames: {\n bubbled: keyOf({onMouseOver: true}),\n captured: keyOf({onMouseOverCapture: true})\n }\n },\n mouseUp: {\n phasedRegistrationNames: {\n bubbled: keyOf({onMouseUp: true}),\n captured: keyOf({onMouseUpCapture: true})\n }\n },\n paste: {\n phasedRegistrationNames: {\n bubbled: keyOf({onPaste: true}),\n captured: keyOf({onPasteCapture: true})\n }\n },\n reset: {\n phasedRegistrationNames: {\n bubbled: keyOf({onReset: true}),\n captured: keyOf({onResetCapture: true})\n }\n },\n scroll: {\n phasedRegistrationNames: {\n bubbled: keyOf({onScroll: true}),\n captured: keyOf({onScrollCapture: true})\n }\n },\n submit: {\n phasedRegistrationNames: {\n bubbled: keyOf({onSubmit: true}),\n captured: keyOf({onSubmitCapture: true})\n }\n },\n touchCancel: {\n phasedRegistrationNames: {\n bubbled: keyOf({onTouchCancel: true}),\n captured: keyOf({onTouchCancelCapture: true})\n }\n },\n touchEnd: {\n phasedRegistrationNames: {\n bubbled: keyOf({onTouchEnd: true}),\n captured: keyOf({onTouchEndCapture: true})\n }\n },\n touchMove: {\n phasedRegistrationNames: {\n bubbled: keyOf({onTouchMove: true}),\n captured: keyOf({onTouchMoveCapture: true})\n }\n },\n touchStart: {\n phasedRegistrationNames: {\n bubbled: keyOf({onTouchStart: true}),\n captured: keyOf({onTouchStartCapture: true})\n }\n },\n wheel: {\n phasedRegistrationNames: {\n bubbled: keyOf({onWheel: true}),\n captured: keyOf({onWheelCapture: true})\n }\n }\n};\n\nvar topLevelEventsToDispatchConfig = {\n topBlur: eventTypes.blur,\n topClick: eventTypes.click,\n topContextMenu: eventTypes.contextMenu,\n topCopy: eventTypes.copy,\n topCut: eventTypes.cut,\n topDoubleClick: eventTypes.doubleClick,\n topDrag: eventTypes.drag,\n topDragEnd: eventTypes.dragEnd,\n topDragEnter: eventTypes.dragEnter,\n topDragExit: eventTypes.dragExit,\n topDragLeave: eventTypes.dragLeave,\n topDragOver: eventTypes.dragOver,\n topDragStart: eventTypes.dragStart,\n topDrop: eventTypes.drop,\n topError: eventTypes.error,\n topFocus: eventTypes.focus,\n topInput: eventTypes.input,\n topKeyDown: eventTypes.keyDown,\n topKeyPress: eventTypes.keyPress,\n topKeyUp: eventTypes.keyUp,\n topLoad: eventTypes.load,\n topMouseDown: eventTypes.mouseDown,\n topMouseMove: eventTypes.mouseMove,\n topMouseOut: eventTypes.mouseOut,\n topMouseOver: eventTypes.mouseOver,\n topMouseUp: eventTypes.mouseUp,\n topPaste: eventTypes.paste,\n topReset: eventTypes.reset,\n topScroll: eventTypes.scroll,\n topSubmit: eventTypes.submit,\n topTouchCancel: eventTypes.touchCancel,\n topTouchEnd: eventTypes.touchEnd,\n topTouchMove: eventTypes.touchMove,\n topTouchStart: eventTypes.touchStart,\n topWheel: eventTypes.wheel\n};\n\nfor (var type in topLevelEventsToDispatchConfig) {\n topLevelEventsToDispatchConfig[type].dependencies = [type];\n}\n\nvar SimpleEventPlugin = {\n\n eventTypes: eventTypes,\n\n /**\n * Same as the default implementation, except cancels the event when return\n * value is false. This behavior will be disabled in a future release.\n *\n * @param {object} Event to be dispatched.\n * @param {function} Application-level callback.\n * @param {string} domID DOM ID to pass to the callback.\n */\n executeDispatch: function(event, listener, domID) {\n var returnValue = EventPluginUtils.executeDispatch(event, listener, domID);\n\n (\"production\" !== process.env.NODE_ENV ? warning(\n typeof returnValue !== 'boolean',\n 'Returning `false` from an event handler is deprecated and will be ' +\n 'ignored in a future release. Instead, manually call ' +\n 'e.stopPropagation() or e.preventDefault(), as appropriate.'\n ) : null);\n\n if (returnValue === false) {\n event.stopPropagation();\n event.preventDefault();\n }\n },\n\n /**\n * @param {string} topLevelType Record from `EventConstants`.\n * @param {DOMEventTarget} topLevelTarget The listening component root node.\n * @param {string} topLevelTargetID ID of `topLevelTarget`.\n * @param {object} nativeEvent Native browser event.\n * @return {*} An accumulation of synthetic events.\n * @see {EventPluginHub.extractEvents}\n */\n extractEvents: function(\n topLevelType,\n topLevelTarget,\n topLevelTargetID,\n nativeEvent) {\n var dispatchConfig = topLevelEventsToDispatchConfig[topLevelType];\n if (!dispatchConfig) {\n return null;\n }\n var EventConstructor;\n switch (topLevelType) {\n case topLevelTypes.topInput:\n case topLevelTypes.topLoad:\n case topLevelTypes.topError:\n case topLevelTypes.topReset:\n case topLevelTypes.topSubmit:\n // HTML Events\n // @see http://www.w3.org/TR/html5/index.html#events-0\n EventConstructor = SyntheticEvent;\n break;\n case topLevelTypes.topKeyPress:\n // FireFox creates a keypress event for function keys too. This removes\n // the unwanted keypress events. Enter is however both printable and\n // non-printable. One would expect Tab to be as well (but it isn't).\n if (getEventCharCode(nativeEvent) === 0) {\n return null;\n }\n /* falls through */\n case topLevelTypes.topKeyDown:\n case topLevelTypes.topKeyUp:\n EventConstructor = SyntheticKeyboardEvent;\n break;\n case topLevelTypes.topBlur:\n case topLevelTypes.topFocus:\n EventConstructor = SyntheticFocusEvent;\n break;\n case topLevelTypes.topClick:\n // Firefox creates a click event on right mouse clicks. This removes the\n // unwanted click events.\n if (nativeEvent.button === 2) {\n return null;\n }\n /* falls through */\n case topLevelTypes.topContextMenu:\n case topLevelTypes.topDoubleClick:\n case topLevelTypes.topMouseDown:\n case topLevelTypes.topMouseMove:\n case topLevelTypes.topMouseOut:\n case topLevelTypes.topMouseOver:\n case topLevelTypes.topMouseUp:\n EventConstructor = SyntheticMouseEvent;\n break;\n case topLevelTypes.topDrag:\n case topLevelTypes.topDragEnd:\n case topLevelTypes.topDragEnter:\n case topLevelTypes.topDragExit:\n case topLevelTypes.topDragLeave:\n case topLevelTypes.topDragOver:\n case topLevelTypes.topDragStart:\n case topLevelTypes.topDrop:\n EventConstructor = SyntheticDragEvent;\n break;\n case topLevelTypes.topTouchCancel:\n case topLevelTypes.topTouchEnd:\n case topLevelTypes.topTouchMove:\n case topLevelTypes.topTouchStart:\n EventConstructor = SyntheticTouchEvent;\n break;\n case topLevelTypes.topScroll:\n EventConstructor = SyntheticUIEvent;\n break;\n case topLevelTypes.topWheel:\n EventConstructor = SyntheticWheelEvent;\n break;\n case topLevelTypes.topCopy:\n case topLevelTypes.topCut:\n case topLevelTypes.topPaste:\n EventConstructor = SyntheticClipboardEvent;\n break;\n }\n (\"production\" !== process.env.NODE_ENV ? invariant(\n EventConstructor,\n 'SimpleEventPlugin: Unhandled event type, `%s`.',\n topLevelType\n ) : invariant(EventConstructor));\n var event = EventConstructor.getPooled(\n dispatchConfig,\n topLevelTargetID,\n nativeEvent\n );\n EventPropagators.accumulateTwoPhaseDispatches(event);\n return event;\n }\n\n};\n\nmodule.exports = SimpleEventPlugin;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/SimpleEventPlugin.js\n ** module id = 199\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/SimpleEventPlugin.js?");
|
||
|
||
/***/ },
|
||
/* 200 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\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 SyntheticDragEvent\n * @typechecks static-only\n */\n\n'use strict';\n\nvar SyntheticMouseEvent = __webpack_require__(165);\n\n/**\n * @interface DragEvent\n * @see http://www.w3.org/TR/DOM-Level-3-Events/\n */\nvar DragEventInterface = {\n dataTransfer: null\n};\n\n/**\n * @param {object} dispatchConfig Configuration used to dispatch this event.\n * @param {string} dispatchMarker Marker identifying the event target.\n * @param {object} nativeEvent Native browser event.\n * @extends {SyntheticUIEvent}\n */\nfunction SyntheticDragEvent(dispatchConfig, dispatchMarker, nativeEvent) {\n SyntheticMouseEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent);\n}\n\nSyntheticMouseEvent.augmentClass(SyntheticDragEvent, DragEventInterface);\n\nmodule.exports = SyntheticDragEvent;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/SyntheticDragEvent.js\n ** module id = 200\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/SyntheticDragEvent.js?");
|
||
|
||
/***/ },
|
||
/* 201 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\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 SyntheticClipboardEvent\n * @typechecks static-only\n */\n\n'use strict';\n\nvar SyntheticEvent = __webpack_require__(157);\n\n/**\n * @interface Event\n * @see http://www.w3.org/TR/clipboard-apis/\n */\nvar ClipboardEventInterface = {\n clipboardData: function(event) {\n return (\n 'clipboardData' in event ?\n event.clipboardData :\n window.clipboardData\n );\n }\n};\n\n/**\n * @param {object} dispatchConfig Configuration used to dispatch this event.\n * @param {string} dispatchMarker Marker identifying the event target.\n * @param {object} nativeEvent Native browser event.\n * @extends {SyntheticUIEvent}\n */\nfunction SyntheticClipboardEvent(dispatchConfig, dispatchMarker, nativeEvent) {\n SyntheticEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent);\n}\n\nSyntheticEvent.augmentClass(SyntheticClipboardEvent, ClipboardEventInterface);\n\nmodule.exports = SyntheticClipboardEvent;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/SyntheticClipboardEvent.js\n ** module id = 201\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/SyntheticClipboardEvent.js?");
|
||
|
||
/***/ },
|
||
/* 202 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\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 SyntheticFocusEvent\n * @typechecks static-only\n */\n\n'use strict';\n\nvar SyntheticUIEvent = __webpack_require__(166);\n\n/**\n * @interface FocusEvent\n * @see http://www.w3.org/TR/DOM-Level-3-Events/\n */\nvar FocusEventInterface = {\n relatedTarget: null\n};\n\n/**\n * @param {object} dispatchConfig Configuration used to dispatch this event.\n * @param {string} dispatchMarker Marker identifying the event target.\n * @param {object} nativeEvent Native browser event.\n * @extends {SyntheticUIEvent}\n */\nfunction SyntheticFocusEvent(dispatchConfig, dispatchMarker, nativeEvent) {\n SyntheticUIEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent);\n}\n\nSyntheticUIEvent.augmentClass(SyntheticFocusEvent, FocusEventInterface);\n\nmodule.exports = SyntheticFocusEvent;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/SyntheticFocusEvent.js\n ** module id = 202\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/SyntheticFocusEvent.js?");
|
||
|
||
/***/ },
|
||
/* 203 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\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 SyntheticKeyboardEvent\n * @typechecks static-only\n */\n\n'use strict';\n\nvar SyntheticUIEvent = __webpack_require__(166);\n\nvar getEventCharCode = __webpack_require__(204);\nvar getEventKey = __webpack_require__(205);\nvar getEventModifierState = __webpack_require__(167);\n\n/**\n * @interface KeyboardEvent\n * @see http://www.w3.org/TR/DOM-Level-3-Events/\n */\nvar KeyboardEventInterface = {\n key: getEventKey,\n location: null,\n ctrlKey: null,\n shiftKey: null,\n altKey: null,\n metaKey: null,\n repeat: null,\n locale: null,\n getModifierState: getEventModifierState,\n // Legacy Interface\n charCode: function(event) {\n // `charCode` is the result of a KeyPress event and represents the value of\n // the actual printable character.\n\n // KeyPress is deprecated, but its replacement is not yet final and not\n // implemented in any major browser. Only KeyPress has charCode.\n if (event.type === 'keypress') {\n return getEventCharCode(event);\n }\n return 0;\n },\n keyCode: function(event) {\n // `keyCode` is the result of a KeyDown/Up event and represents the value of\n // physical keyboard key.\n\n // The actual meaning of the value depends on the users' keyboard layout\n // which cannot be detected. Assuming that it is a US keyboard layout\n // provides a surprisingly accurate mapping for US and European users.\n // Due to this, it is left to the user to implement at this time.\n if (event.type === 'keydown' || event.type === 'keyup') {\n return event.keyCode;\n }\n return 0;\n },\n which: function(event) {\n // `which` is an alias for either `keyCode` or `charCode` depending on the\n // type of the event.\n if (event.type === 'keypress') {\n return getEventCharCode(event);\n }\n if (event.type === 'keydown' || event.type === 'keyup') {\n return event.keyCode;\n }\n return 0;\n }\n};\n\n/**\n * @param {object} dispatchConfig Configuration used to dispatch this event.\n * @param {string} dispatchMarker Marker identifying the event target.\n * @param {object} nativeEvent Native browser event.\n * @extends {SyntheticUIEvent}\n */\nfunction SyntheticKeyboardEvent(dispatchConfig, dispatchMarker, nativeEvent) {\n SyntheticUIEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent);\n}\n\nSyntheticUIEvent.augmentClass(SyntheticKeyboardEvent, KeyboardEventInterface);\n\nmodule.exports = SyntheticKeyboardEvent;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/SyntheticKeyboardEvent.js\n ** module id = 203\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/SyntheticKeyboardEvent.js?");
|
||
|
||
/***/ },
|
||
/* 204 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("/**\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 getEventCharCode\n * @typechecks static-only\n */\n\n'use strict';\n\n/**\n * `charCode` represents the actual \"character code\" and is safe to use with\n * `String.fromCharCode`. As such, only keys that correspond to printable\n * characters produce a valid `charCode`, the only exception to this is Enter.\n * The Tab-key is considered non-printable and does not have a `charCode`,\n * presumably because it does not produce a tab-character in browsers.\n *\n * @param {object} nativeEvent Native browser event.\n * @return {string} Normalized `charCode` property.\n */\nfunction getEventCharCode(nativeEvent) {\n var charCode;\n var keyCode = nativeEvent.keyCode;\n\n if ('charCode' in nativeEvent) {\n charCode = nativeEvent.charCode;\n\n // FF does not set `charCode` for the Enter-key, check against `keyCode`.\n if (charCode === 0 && keyCode === 13) {\n charCode = 13;\n }\n } else {\n // IE8 does not implement `charCode`, but `keyCode` has the correct value.\n charCode = keyCode;\n }\n\n // Some non-printable keys are reported in `charCode`/`keyCode`, discard them.\n // Must not discard the (non-)printable Enter-key.\n if (charCode >= 32 || charCode === 13) {\n return charCode;\n }\n\n return 0;\n}\n\nmodule.exports = getEventCharCode;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/getEventCharCode.js\n ** module id = 204\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/getEventCharCode.js?");
|
||
|
||
/***/ },
|
||
/* 205 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\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 getEventKey\n * @typechecks static-only\n */\n\n'use strict';\n\nvar getEventCharCode = __webpack_require__(204);\n\n/**\n * Normalization of deprecated HTML5 `key` values\n * @see https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent#Key_names\n */\nvar normalizeKey = {\n 'Esc': 'Escape',\n 'Spacebar': ' ',\n 'Left': 'ArrowLeft',\n 'Up': 'ArrowUp',\n 'Right': 'ArrowRight',\n 'Down': 'ArrowDown',\n 'Del': 'Delete',\n 'Win': 'OS',\n 'Menu': 'ContextMenu',\n 'Apps': 'ContextMenu',\n 'Scroll': 'ScrollLock',\n 'MozPrintableKey': 'Unidentified'\n};\n\n/**\n * Translation from legacy `keyCode` to HTML5 `key`\n * Only special keys supported, all others depend on keyboard layout or browser\n * @see https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent#Key_names\n */\nvar translateToKey = {\n 8: 'Backspace',\n 9: 'Tab',\n 12: 'Clear',\n 13: 'Enter',\n 16: 'Shift',\n 17: 'Control',\n 18: 'Alt',\n 19: 'Pause',\n 20: 'CapsLock',\n 27: 'Escape',\n 32: ' ',\n 33: 'PageUp',\n 34: 'PageDown',\n 35: 'End',\n 36: 'Home',\n 37: 'ArrowLeft',\n 38: 'ArrowUp',\n 39: 'ArrowRight',\n 40: 'ArrowDown',\n 45: 'Insert',\n 46: 'Delete',\n 112: 'F1', 113: 'F2', 114: 'F3', 115: 'F4', 116: 'F5', 117: 'F6',\n 118: 'F7', 119: 'F8', 120: 'F9', 121: 'F10', 122: 'F11', 123: 'F12',\n 144: 'NumLock',\n 145: 'ScrollLock',\n 224: 'Meta'\n};\n\n/**\n * @param {object} nativeEvent Native browser event.\n * @return {string} Normalized `key` property.\n */\nfunction getEventKey(nativeEvent) {\n if (nativeEvent.key) {\n // Normalize inconsistent values reported by browsers due to\n // implementations of a working draft specification.\n\n // FireFox implements `key` but returns `MozPrintableKey` for all\n // printable characters (normalized to `Unidentified`), ignore it.\n var key = normalizeKey[nativeEvent.key] || nativeEvent.key;\n if (key !== 'Unidentified') {\n return key;\n }\n }\n\n // Browser does not implement `key`, polyfill as much of it as we can.\n if (nativeEvent.type === 'keypress') {\n var charCode = getEventCharCode(nativeEvent);\n\n // The enter-key is technically both printable and non-printable and can\n // thus be captured by `keypress`, no other non-printable key should.\n return charCode === 13 ? 'Enter' : String.fromCharCode(charCode);\n }\n if (nativeEvent.type === 'keydown' || nativeEvent.type === 'keyup') {\n // While user keyboard layout determines the actual meaning of each\n // `keyCode` value, almost all function keys have a universal value.\n return translateToKey[nativeEvent.keyCode] || 'Unidentified';\n }\n return '';\n}\n\nmodule.exports = getEventKey;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/getEventKey.js\n ** module id = 205\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/getEventKey.js?");
|
||
|
||
/***/ },
|
||
/* 206 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\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 SyntheticTouchEvent\n * @typechecks static-only\n */\n\n'use strict';\n\nvar SyntheticUIEvent = __webpack_require__(166);\n\nvar getEventModifierState = __webpack_require__(167);\n\n/**\n * @interface TouchEvent\n * @see http://www.w3.org/TR/touch-events/\n */\nvar TouchEventInterface = {\n touches: null,\n targetTouches: null,\n changedTouches: null,\n altKey: null,\n metaKey: null,\n ctrlKey: null,\n shiftKey: null,\n getModifierState: getEventModifierState\n};\n\n/**\n * @param {object} dispatchConfig Configuration used to dispatch this event.\n * @param {string} dispatchMarker Marker identifying the event target.\n * @param {object} nativeEvent Native browser event.\n * @extends {SyntheticUIEvent}\n */\nfunction SyntheticTouchEvent(dispatchConfig, dispatchMarker, nativeEvent) {\n SyntheticUIEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent);\n}\n\nSyntheticUIEvent.augmentClass(SyntheticTouchEvent, TouchEventInterface);\n\nmodule.exports = SyntheticTouchEvent;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/SyntheticTouchEvent.js\n ** module id = 206\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/SyntheticTouchEvent.js?");
|
||
|
||
/***/ },
|
||
/* 207 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\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 SyntheticWheelEvent\n * @typechecks static-only\n */\n\n'use strict';\n\nvar SyntheticMouseEvent = __webpack_require__(165);\n\n/**\n * @interface WheelEvent\n * @see http://www.w3.org/TR/DOM-Level-3-Events/\n */\nvar WheelEventInterface = {\n deltaX: function(event) {\n return (\n 'deltaX' in event ? event.deltaX :\n // Fallback to `wheelDeltaX` for Webkit and normalize (right is positive).\n 'wheelDeltaX' in event ? -event.wheelDeltaX : 0\n );\n },\n deltaY: function(event) {\n return (\n 'deltaY' in event ? event.deltaY :\n // Fallback to `wheelDeltaY` for Webkit and normalize (down is positive).\n 'wheelDeltaY' in event ? -event.wheelDeltaY :\n // Fallback to `wheelDelta` for IE<9 and normalize (down is positive).\n 'wheelDelta' in event ? -event.wheelDelta : 0\n );\n },\n deltaZ: null,\n\n // Browsers without \"deltaMode\" is reporting in raw wheel delta where one\n // notch on the scroll is always +/- 120, roughly equivalent to pixels.\n // A good approximation of DOM_DELTA_LINE (1) is 5% of viewport size or\n // ~40 pixels, for DOM_DELTA_SCREEN (2) it is 87.5% of viewport size.\n deltaMode: null\n};\n\n/**\n * @param {object} dispatchConfig Configuration used to dispatch this event.\n * @param {string} dispatchMarker Marker identifying the event target.\n * @param {object} nativeEvent Native browser event.\n * @extends {SyntheticMouseEvent}\n */\nfunction SyntheticWheelEvent(dispatchConfig, dispatchMarker, nativeEvent) {\n SyntheticMouseEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent);\n}\n\nSyntheticMouseEvent.augmentClass(SyntheticWheelEvent, WheelEventInterface);\n\nmodule.exports = SyntheticWheelEvent;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/SyntheticWheelEvent.js\n ** module id = 207\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/SyntheticWheelEvent.js?");
|
||
|
||
/***/ },
|
||
/* 208 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\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 SVGDOMPropertyConfig\n */\n\n/*jslint bitwise: true*/\n\n'use strict';\n\nvar DOMProperty = __webpack_require__(63);\n\nvar MUST_USE_ATTRIBUTE = DOMProperty.injection.MUST_USE_ATTRIBUTE;\n\nvar SVGDOMPropertyConfig = {\n Properties: {\n clipPath: MUST_USE_ATTRIBUTE,\n cx: MUST_USE_ATTRIBUTE,\n cy: MUST_USE_ATTRIBUTE,\n d: MUST_USE_ATTRIBUTE,\n dx: MUST_USE_ATTRIBUTE,\n dy: MUST_USE_ATTRIBUTE,\n fill: MUST_USE_ATTRIBUTE,\n fillOpacity: MUST_USE_ATTRIBUTE,\n fontFamily: MUST_USE_ATTRIBUTE,\n fontSize: MUST_USE_ATTRIBUTE,\n fx: MUST_USE_ATTRIBUTE,\n fy: MUST_USE_ATTRIBUTE,\n gradientTransform: MUST_USE_ATTRIBUTE,\n gradientUnits: MUST_USE_ATTRIBUTE,\n markerEnd: MUST_USE_ATTRIBUTE,\n markerMid: MUST_USE_ATTRIBUTE,\n markerStart: MUST_USE_ATTRIBUTE,\n offset: MUST_USE_ATTRIBUTE,\n opacity: MUST_USE_ATTRIBUTE,\n patternContentUnits: MUST_USE_ATTRIBUTE,\n patternUnits: MUST_USE_ATTRIBUTE,\n points: MUST_USE_ATTRIBUTE,\n preserveAspectRatio: MUST_USE_ATTRIBUTE,\n r: MUST_USE_ATTRIBUTE,\n rx: MUST_USE_ATTRIBUTE,\n ry: MUST_USE_ATTRIBUTE,\n spreadMethod: MUST_USE_ATTRIBUTE,\n stopColor: MUST_USE_ATTRIBUTE,\n stopOpacity: MUST_USE_ATTRIBUTE,\n stroke: MUST_USE_ATTRIBUTE,\n strokeDasharray: MUST_USE_ATTRIBUTE,\n strokeLinecap: MUST_USE_ATTRIBUTE,\n strokeOpacity: MUST_USE_ATTRIBUTE,\n strokeWidth: MUST_USE_ATTRIBUTE,\n textAnchor: MUST_USE_ATTRIBUTE,\n transform: MUST_USE_ATTRIBUTE,\n version: MUST_USE_ATTRIBUTE,\n viewBox: MUST_USE_ATTRIBUTE,\n x1: MUST_USE_ATTRIBUTE,\n x2: MUST_USE_ATTRIBUTE,\n x: MUST_USE_ATTRIBUTE,\n y1: MUST_USE_ATTRIBUTE,\n y2: MUST_USE_ATTRIBUTE,\n y: MUST_USE_ATTRIBUTE\n },\n DOMAttributeNames: {\n clipPath: 'clip-path',\n fillOpacity: 'fill-opacity',\n fontFamily: 'font-family',\n fontSize: 'font-size',\n gradientTransform: 'gradientTransform',\n gradientUnits: 'gradientUnits',\n markerEnd: 'marker-end',\n markerMid: 'marker-mid',\n markerStart: 'marker-start',\n patternContentUnits: 'patternContentUnits',\n patternUnits: 'patternUnits',\n preserveAspectRatio: 'preserveAspectRatio',\n spreadMethod: 'spreadMethod',\n stopColor: 'stop-color',\n stopOpacity: 'stop-opacity',\n strokeDasharray: 'stroke-dasharray',\n strokeLinecap: 'stroke-linecap',\n strokeOpacity: 'stroke-opacity',\n strokeWidth: 'stroke-width',\n textAnchor: 'text-anchor',\n viewBox: 'viewBox'\n }\n};\n\nmodule.exports = SVGDOMPropertyConfig;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/SVGDOMPropertyConfig.js\n ** module id = 208\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/SVGDOMPropertyConfig.js?");
|
||
|
||
/***/ },
|
||
/* 209 */
|
||
/***/ 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 createFullPageComponent\n * @typechecks\n */\n\n'use strict';\n\n// Defeat circular references by requiring this directly.\nvar ReactClass = __webpack_require__(120);\nvar ReactElement = __webpack_require__(79);\n\nvar invariant = __webpack_require__(64);\n\n/**\n * Create a component that will throw an exception when unmounted.\n *\n * Components like <html> <head> and <body> can't be removed or added\n * easily in a cross-browser way, however it's valuable to be able to\n * take advantage of React's reconciliation for styling and <title>\n * management. So we just document it and throw in dangerous cases.\n *\n * @param {string} tag The tag to wrap\n * @return {function} convenience constructor of new component\n */\nfunction createFullPageComponent(tag) {\n var elementFactory = ReactElement.createFactory(tag);\n\n var FullPageComponent = ReactClass.createClass({\n tagName: tag.toUpperCase(),\n displayName: 'ReactFullPageComponent' + tag,\n\n componentWillUnmount: function() {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n false,\n '%s tried to unmount. Because of cross-browser quirks it is ' +\n 'impossible to unmount some top-level components (eg <html>, <head>, ' +\n 'and <body>) reliably and efficiently. To fix this, have a single ' +\n 'top-level component that never unmounts render these elements.',\n this.constructor.displayName\n ) : invariant(false));\n },\n\n render: function() {\n return elementFactory(this.props);\n }\n });\n\n return FullPageComponent;\n}\n\nmodule.exports = createFullPageComponent;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/createFullPageComponent.js\n ** module id = 209\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/createFullPageComponent.js?");
|
||
|
||
/***/ },
|
||
/* 210 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\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 ReactDefaultPerf\n * @typechecks static-only\n */\n\n'use strict';\n\nvar DOMProperty = __webpack_require__(63);\nvar ReactDefaultPerfAnalysis = __webpack_require__(211);\nvar ReactMount = __webpack_require__(61);\nvar ReactPerf = __webpack_require__(96);\n\nvar performanceNow = __webpack_require__(212);\n\nfunction roundFloat(val) {\n return Math.floor(val * 100) / 100;\n}\n\nfunction addValue(obj, key, val) {\n obj[key] = (obj[key] || 0) + val;\n}\n\nvar ReactDefaultPerf = {\n _allMeasurements: [], // last item in the list is the current one\n _mountStack: [0],\n _injected: false,\n\n start: function() {\n if (!ReactDefaultPerf._injected) {\n ReactPerf.injection.injectMeasure(ReactDefaultPerf.measure);\n }\n\n ReactDefaultPerf._allMeasurements.length = 0;\n ReactPerf.enableMeasure = true;\n },\n\n stop: function() {\n ReactPerf.enableMeasure = false;\n },\n\n getLastMeasurements: function() {\n return ReactDefaultPerf._allMeasurements;\n },\n\n printExclusive: function(measurements) {\n measurements = measurements || ReactDefaultPerf._allMeasurements;\n var summary = ReactDefaultPerfAnalysis.getExclusiveSummary(measurements);\n console.table(summary.map(function(item) {\n return {\n 'Component class name': item.componentName,\n 'Total inclusive time (ms)': roundFloat(item.inclusive),\n 'Exclusive mount time (ms)': roundFloat(item.exclusive),\n 'Exclusive render time (ms)': roundFloat(item.render),\n 'Mount time per instance (ms)': roundFloat(item.exclusive / item.count),\n 'Render time per instance (ms)': roundFloat(item.render / item.count),\n 'Instances': item.count\n };\n }));\n // TODO: ReactDefaultPerfAnalysis.getTotalTime() does not return the correct\n // number.\n },\n\n printInclusive: function(measurements) {\n measurements = measurements || ReactDefaultPerf._allMeasurements;\n var summary = ReactDefaultPerfAnalysis.getInclusiveSummary(measurements);\n console.table(summary.map(function(item) {\n return {\n 'Owner > component': item.componentName,\n 'Inclusive time (ms)': roundFloat(item.time),\n 'Instances': item.count\n };\n }));\n console.log(\n 'Total time:',\n ReactDefaultPerfAnalysis.getTotalTime(measurements).toFixed(2) + ' ms'\n );\n },\n\n getMeasurementsSummaryMap: function(measurements) {\n var summary = ReactDefaultPerfAnalysis.getInclusiveSummary(\n measurements,\n true\n );\n return summary.map(function(item) {\n return {\n 'Owner > component': item.componentName,\n 'Wasted time (ms)': item.time,\n 'Instances': item.count\n };\n });\n },\n\n printWasted: function(measurements) {\n measurements = measurements || ReactDefaultPerf._allMeasurements;\n console.table(ReactDefaultPerf.getMeasurementsSummaryMap(measurements));\n console.log(\n 'Total time:',\n ReactDefaultPerfAnalysis.getTotalTime(measurements).toFixed(2) + ' ms'\n );\n },\n\n printDOM: function(measurements) {\n measurements = measurements || ReactDefaultPerf._allMeasurements;\n var summary = ReactDefaultPerfAnalysis.getDOMSummary(measurements);\n console.table(summary.map(function(item) {\n var result = {};\n result[DOMProperty.ID_ATTRIBUTE_NAME] = item.id;\n result['type'] = item.type;\n result['args'] = JSON.stringify(item.args);\n return result;\n }));\n console.log(\n 'Total time:',\n ReactDefaultPerfAnalysis.getTotalTime(measurements).toFixed(2) + ' ms'\n );\n },\n\n _recordWrite: function(id, fnName, totalTime, args) {\n // TODO: totalTime isn't that useful since it doesn't count paints/reflows\n var writes =\n ReactDefaultPerf\n ._allMeasurements[ReactDefaultPerf._allMeasurements.length - 1]\n .writes;\n writes[id] = writes[id] || [];\n writes[id].push({\n type: fnName,\n time: totalTime,\n args: args\n });\n },\n\n measure: function(moduleName, fnName, func) {\n return function() {for (var args=[],$__0=0,$__1=arguments.length;$__0<$__1;$__0++) args.push(arguments[$__0]);\n var totalTime;\n var rv;\n var start;\n\n if (fnName === '_renderNewRootComponent' ||\n fnName === 'flushBatchedUpdates') {\n // A \"measurement\" is a set of metrics recorded for each flush. We want\n // to group the metrics for a given flush together so we can look at the\n // components that rendered and the DOM operations that actually\n // happened to determine the amount of \"wasted work\" performed.\n ReactDefaultPerf._allMeasurements.push({\n exclusive: {},\n inclusive: {},\n render: {},\n counts: {},\n writes: {},\n displayNames: {},\n totalTime: 0\n });\n start = performanceNow();\n rv = func.apply(this, args);\n ReactDefaultPerf._allMeasurements[\n ReactDefaultPerf._allMeasurements.length - 1\n ].totalTime = performanceNow() - start;\n return rv;\n } else if (fnName === '_mountImageIntoNode' ||\n moduleName === 'ReactDOMIDOperations') {\n start = performanceNow();\n rv = func.apply(this, args);\n totalTime = performanceNow() - start;\n\n if (fnName === '_mountImageIntoNode') {\n var mountID = ReactMount.getID(args[1]);\n ReactDefaultPerf._recordWrite(mountID, fnName, totalTime, args[0]);\n } else if (fnName === 'dangerouslyProcessChildrenUpdates') {\n // special format\n args[0].forEach(function(update) {\n var writeArgs = {};\n if (update.fromIndex !== null) {\n writeArgs.fromIndex = update.fromIndex;\n }\n if (update.toIndex !== null) {\n writeArgs.toIndex = update.toIndex;\n }\n if (update.textContent !== null) {\n writeArgs.textContent = update.textContent;\n }\n if (update.markupIndex !== null) {\n writeArgs.markup = args[1][update.markupIndex];\n }\n ReactDefaultPerf._recordWrite(\n update.parentID,\n update.type,\n totalTime,\n writeArgs\n );\n });\n } else {\n // basic format\n ReactDefaultPerf._recordWrite(\n args[0],\n fnName,\n totalTime,\n Array.prototype.slice.call(args, 1)\n );\n }\n return rv;\n } else if (moduleName === 'ReactCompositeComponent' && (\n (// TODO: receiveComponent()?\n (fnName === 'mountComponent' ||\n fnName === 'updateComponent' || fnName === '_renderValidatedComponent')))) {\n\n if (typeof this._currentElement.type === 'string') {\n return func.apply(this, args);\n }\n\n var rootNodeID = fnName === 'mountComponent' ?\n args[0] :\n this._rootNodeID;\n var isRender = fnName === '_renderValidatedComponent';\n var isMount = fnName === 'mountComponent';\n\n var mountStack = ReactDefaultPerf._mountStack;\n var entry = ReactDefaultPerf._allMeasurements[\n ReactDefaultPerf._allMeasurements.length - 1\n ];\n\n if (isRender) {\n addValue(entry.counts, rootNodeID, 1);\n } else if (isMount) {\n mountStack.push(0);\n }\n\n start = performanceNow();\n rv = func.apply(this, args);\n totalTime = performanceNow() - start;\n\n if (isRender) {\n addValue(entry.render, rootNodeID, totalTime);\n } else if (isMount) {\n var subMountTime = mountStack.pop();\n mountStack[mountStack.length - 1] += totalTime;\n addValue(entry.exclusive, rootNodeID, totalTime - subMountTime);\n addValue(entry.inclusive, rootNodeID, totalTime);\n } else {\n addValue(entry.inclusive, rootNodeID, totalTime);\n }\n\n entry.displayNames[rootNodeID] = {\n current: this.getName(),\n owner: this._currentElement._owner ?\n this._currentElement._owner.getName() :\n '<root>'\n };\n\n return rv;\n } else {\n return func.apply(this, args);\n }\n };\n }\n};\n\nmodule.exports = ReactDefaultPerf;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactDefaultPerf.js\n ** module id = 210\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ReactDefaultPerf.js?");
|
||
|
||
/***/ },
|
||
/* 211 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\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 ReactDefaultPerfAnalysis\n */\n\nvar assign = __webpack_require__(75);\n\n// Don't try to save users less than 1.2ms (a number I made up)\nvar DONT_CARE_THRESHOLD = 1.2;\nvar DOM_OPERATION_TYPES = {\n '_mountImageIntoNode': 'set innerHTML',\n INSERT_MARKUP: 'set innerHTML',\n MOVE_EXISTING: 'move',\n REMOVE_NODE: 'remove',\n TEXT_CONTENT: 'set textContent',\n 'updatePropertyByID': 'update attribute',\n 'deletePropertyByID': 'delete attribute',\n 'updateStylesByID': 'update styles',\n 'updateInnerHTMLByID': 'set innerHTML',\n 'dangerouslyReplaceNodeWithMarkupByID': 'replace'\n};\n\nfunction getTotalTime(measurements) {\n // TODO: return number of DOM ops? could be misleading.\n // TODO: measure dropped frames after reconcile?\n // TODO: log total time of each reconcile and the top-level component\n // class that triggered it.\n var totalTime = 0;\n for (var i = 0; i < measurements.length; i++) {\n var measurement = measurements[i];\n totalTime += measurement.totalTime;\n }\n return totalTime;\n}\n\nfunction getDOMSummary(measurements) {\n var items = [];\n for (var i = 0; i < measurements.length; i++) {\n var measurement = measurements[i];\n var id;\n\n for (id in measurement.writes) {\n measurement.writes[id].forEach(function(write) {\n items.push({\n id: id,\n type: DOM_OPERATION_TYPES[write.type] || write.type,\n args: write.args\n });\n });\n }\n }\n return items;\n}\n\nfunction getExclusiveSummary(measurements) {\n var candidates = {};\n var displayName;\n\n for (var i = 0; i < measurements.length; i++) {\n var measurement = measurements[i];\n var allIDs = assign(\n {},\n measurement.exclusive,\n measurement.inclusive\n );\n\n for (var id in allIDs) {\n displayName = measurement.displayNames[id].current;\n\n candidates[displayName] = candidates[displayName] || {\n componentName: displayName,\n inclusive: 0,\n exclusive: 0,\n render: 0,\n count: 0\n };\n if (measurement.render[id]) {\n candidates[displayName].render += measurement.render[id];\n }\n if (measurement.exclusive[id]) {\n candidates[displayName].exclusive += measurement.exclusive[id];\n }\n if (measurement.inclusive[id]) {\n candidates[displayName].inclusive += measurement.inclusive[id];\n }\n if (measurement.counts[id]) {\n candidates[displayName].count += measurement.counts[id];\n }\n }\n }\n\n // Now make a sorted array with the results.\n var arr = [];\n for (displayName in candidates) {\n if (candidates[displayName].exclusive >= DONT_CARE_THRESHOLD) {\n arr.push(candidates[displayName]);\n }\n }\n\n arr.sort(function(a, b) {\n return b.exclusive - a.exclusive;\n });\n\n return arr;\n}\n\nfunction getInclusiveSummary(measurements, onlyClean) {\n var candidates = {};\n var inclusiveKey;\n\n for (var i = 0; i < measurements.length; i++) {\n var measurement = measurements[i];\n var allIDs = assign(\n {},\n measurement.exclusive,\n measurement.inclusive\n );\n var cleanComponents;\n\n if (onlyClean) {\n cleanComponents = getUnchangedComponents(measurement);\n }\n\n for (var id in allIDs) {\n if (onlyClean && !cleanComponents[id]) {\n continue;\n }\n\n var displayName = measurement.displayNames[id];\n\n // Inclusive time is not useful for many components without knowing where\n // they are instantiated. So we aggregate inclusive time with both the\n // owner and current displayName as the key.\n inclusiveKey = displayName.owner + ' > ' + displayName.current;\n\n candidates[inclusiveKey] = candidates[inclusiveKey] || {\n componentName: inclusiveKey,\n time: 0,\n count: 0\n };\n\n if (measurement.inclusive[id]) {\n candidates[inclusiveKey].time += measurement.inclusive[id];\n }\n if (measurement.counts[id]) {\n candidates[inclusiveKey].count += measurement.counts[id];\n }\n }\n }\n\n // Now make a sorted array with the results.\n var arr = [];\n for (inclusiveKey in candidates) {\n if (candidates[inclusiveKey].time >= DONT_CARE_THRESHOLD) {\n arr.push(candidates[inclusiveKey]);\n }\n }\n\n arr.sort(function(a, b) {\n return b.time - a.time;\n });\n\n return arr;\n}\n\nfunction getUnchangedComponents(measurement) {\n // For a given reconcile, look at which components did not actually\n // render anything to the DOM and return a mapping of their ID to\n // the amount of time it took to render the entire subtree.\n var cleanComponents = {};\n var dirtyLeafIDs = Object.keys(measurement.writes);\n var allIDs = assign({}, measurement.exclusive, measurement.inclusive);\n\n for (var id in allIDs) {\n var isDirty = false;\n // For each component that rendered, see if a component that triggered\n // a DOM op is in its subtree.\n for (var i = 0; i < dirtyLeafIDs.length; i++) {\n if (dirtyLeafIDs[i].indexOf(id) === 0) {\n isDirty = true;\n break;\n }\n }\n if (!isDirty && measurement.counts[id] > 0) {\n cleanComponents[id] = true;\n }\n }\n return cleanComponents;\n}\n\nvar ReactDefaultPerfAnalysis = {\n getExclusiveSummary: getExclusiveSummary,\n getInclusiveSummary: getInclusiveSummary,\n getDOMSummary: getDOMSummary,\n getTotalTime: getTotalTime\n};\n\nmodule.exports = ReactDefaultPerfAnalysis;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactDefaultPerfAnalysis.js\n ** module id = 211\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ReactDefaultPerfAnalysis.js?");
|
||
|
||
/***/ },
|
||
/* 212 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\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 performanceNow\n * @typechecks\n */\n\nvar performance = __webpack_require__(213);\n\n/**\n * Detect if we can use `window.performance.now()` and gracefully fallback to\n * `Date.now()` if it doesn't exist. We need to support Firefox < 15 for now\n * because of Facebook's testing infrastructure.\n */\nif (!performance || !performance.now) {\n performance = Date;\n}\n\nvar performanceNow = performance.now.bind(performance);\n\nmodule.exports = performanceNow;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/performanceNow.js\n ** module id = 212\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/performanceNow.js?");
|
||
|
||
/***/ },
|
||
/* 213 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\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 performance\n * @typechecks\n */\n\n\"use strict\";\n\nvar ExecutionEnvironment = __webpack_require__(77);\n\nvar performance;\n\nif (ExecutionEnvironment.canUseDOM) {\n performance =\n window.performance ||\n window.msPerformance ||\n window.webkitPerformance;\n}\n\nmodule.exports = performance || {};\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/performance.js\n ** module id = 213\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/performance.js?");
|
||
|
||
/***/ },
|
||
/* 214 */
|
||
/***/ 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 * @typechecks static-only\n * @providesModule ReactServerRendering\n */\n'use strict';\n\nvar ReactElement = __webpack_require__(79);\nvar ReactInstanceHandles = __webpack_require__(92);\nvar ReactMarkupChecksum = __webpack_require__(94);\nvar ReactServerRenderingTransaction =\n __webpack_require__(215);\n\nvar emptyObject = __webpack_require__(81);\nvar instantiateReactComponent = __webpack_require__(110);\nvar invariant = __webpack_require__(64);\n\n/**\n * @param {ReactElement} element\n * @return {string} the HTML markup\n */\nfunction renderToString(element) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n ReactElement.isValidElement(element),\n 'renderToString(): You must pass a valid ReactElement.'\n ) : invariant(ReactElement.isValidElement(element)));\n\n var transaction;\n try {\n var id = ReactInstanceHandles.createReactRootID();\n transaction = ReactServerRenderingTransaction.getPooled(false);\n\n return transaction.perform(function() {\n var componentInstance = instantiateReactComponent(element, null);\n var markup =\n componentInstance.mountComponent(id, transaction, emptyObject);\n return ReactMarkupChecksum.addChecksumToMarkup(markup);\n }, null);\n } finally {\n ReactServerRenderingTransaction.release(transaction);\n }\n}\n\n/**\n * @param {ReactElement} element\n * @return {string} the HTML markup, without the extra React ID and checksum\n * (for generating static pages)\n */\nfunction renderToStaticMarkup(element) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n ReactElement.isValidElement(element),\n 'renderToStaticMarkup(): You must pass a valid ReactElement.'\n ) : invariant(ReactElement.isValidElement(element)));\n\n var transaction;\n try {\n var id = ReactInstanceHandles.createReactRootID();\n transaction = ReactServerRenderingTransaction.getPooled(true);\n\n return transaction.perform(function() {\n var componentInstance = instantiateReactComponent(element, null);\n return componentInstance.mountComponent(id, transaction, emptyObject);\n }, null);\n } finally {\n ReactServerRenderingTransaction.release(transaction);\n }\n}\n\nmodule.exports = {\n renderToString: renderToString,\n renderToStaticMarkup: renderToStaticMarkup\n};\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactServerRendering.js\n ** module id = 214\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ReactServerRendering.js?");
|
||
|
||
/***/ },
|
||
/* 215 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/**\n * Copyright 2014-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 ReactServerRenderingTransaction\n * @typechecks\n */\n\n'use strict';\n\nvar PooledClass = __webpack_require__(103);\nvar CallbackQueue = __webpack_require__(102);\nvar ReactPutListenerQueue = __webpack_require__(195);\nvar Transaction = __webpack_require__(104);\n\nvar assign = __webpack_require__(75);\nvar emptyFunction = __webpack_require__(83);\n\n/**\n * Provides a `CallbackQueue` queue for collecting `onDOMReady` callbacks\n * during the performing of the transaction.\n */\nvar ON_DOM_READY_QUEUEING = {\n /**\n * Initializes the internal `onDOMReady` queue.\n */\n initialize: function() {\n this.reactMountReady.reset();\n },\n\n close: emptyFunction\n};\n\nvar PUT_LISTENER_QUEUEING = {\n initialize: function() {\n this.putListenerQueue.reset();\n },\n\n close: emptyFunction\n};\n\n/**\n * Executed within the scope of the `Transaction` instance. Consider these as\n * being member methods, but with an implied ordering while being isolated from\n * each other.\n */\nvar TRANSACTION_WRAPPERS = [\n PUT_LISTENER_QUEUEING,\n ON_DOM_READY_QUEUEING\n];\n\n/**\n * @class ReactServerRenderingTransaction\n * @param {boolean} renderToStaticMarkup\n */\nfunction ReactServerRenderingTransaction(renderToStaticMarkup) {\n this.reinitializeTransaction();\n this.renderToStaticMarkup = renderToStaticMarkup;\n this.reactMountReady = CallbackQueue.getPooled(null);\n this.putListenerQueue = ReactPutListenerQueue.getPooled();\n}\n\nvar Mixin = {\n /**\n * @see Transaction\n * @abstract\n * @final\n * @return {array} Empty list of operation wrap proceedures.\n */\n getTransactionWrappers: function() {\n return TRANSACTION_WRAPPERS;\n },\n\n /**\n * @return {object} The queue to collect `onDOMReady` callbacks with.\n */\n getReactMountReady: function() {\n return this.reactMountReady;\n },\n\n getPutListenerQueue: function() {\n return this.putListenerQueue;\n },\n\n /**\n * `PooledClass` looks for this, and will invoke this before allowing this\n * instance to be resused.\n */\n destructor: function() {\n CallbackQueue.release(this.reactMountReady);\n this.reactMountReady = null;\n\n ReactPutListenerQueue.release(this.putListenerQueue);\n this.putListenerQueue = null;\n }\n};\n\n\nassign(\n ReactServerRenderingTransaction.prototype,\n Transaction.Mixin,\n Mixin\n);\n\nPooledClass.addPoolingTo(ReactServerRenderingTransaction);\n\nmodule.exports = ReactServerRenderingTransaction;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactServerRenderingTransaction.js\n ** module id = 215\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/ReactServerRenderingTransaction.js?");
|
||
|
||
/***/ },
|
||
/* 216 */
|
||
/***/ 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 onlyChild\n */\n'use strict';\n\nvar ReactElement = __webpack_require__(79);\n\nvar invariant = __webpack_require__(64);\n\n/**\n * Returns the first child in a collection of children and verifies that there\n * is only one child in the collection. The current implementation of this\n * function assumes that a single child gets passed without a wrapper, but the\n * purpose of this helper function is to abstract away the particular structure\n * of children.\n *\n * @param {?object} children Child collection structure.\n * @return {ReactComponent} The first and only `ReactComponent` contained in the\n * structure.\n */\nfunction onlyChild(children) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n ReactElement.isValidElement(children),\n 'onlyChild must be passed a children with exactly one child.'\n ) : invariant(ReactElement.isValidElement(children)));\n return children;\n}\n\nmodule.exports = onlyChild;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/onlyChild.js\n ** module id = 216\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react/lib/onlyChild.js?");
|
||
|
||
/***/ },
|
||
/* 217 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("'use strict';\n\nmodule.exports = __webpack_require__(218);\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react-hot-loader/~/react-hot-api/modules/index.js\n ** module id = 217\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react-hot-loader/~/react-hot-api/modules/index.js?");
|
||
|
||
/***/ },
|
||
/* 218 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("'use strict';\n\nvar makePatchReactClass = __webpack_require__(219);\n\n/**\n * Returns a function that, when invoked, patches a React class with a new\n * version of itself. To patch different classes, pass different IDs.\n */\nmodule.exports = function makeMakeHot(getRootInstances, React) {\n if (typeof getRootInstances !== 'function') {\n throw new Error('Expected getRootInstances to be a function.');\n }\n\n var patchers = {};\n\n return function makeHot(NextClass, persistentId) {\n persistentId = persistentId || NextClass.displayName || NextClass.name;\n\n if (!persistentId) {\n console.error(\n 'Hot reload is disabled for one of your types. To enable it, pass a ' +\n 'string uniquely identifying this class within this current module ' +\n 'as a second parameter to makeHot.'\n );\n return NextClass;\n }\n\n if (!patchers[persistentId]) {\n patchers[persistentId] = makePatchReactClass(getRootInstances, React);\n }\n\n var patchReactClass = patchers[persistentId];\n return patchReactClass(NextClass);\n };\n};\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react-hot-loader/~/react-hot-api/modules/makeMakeHot.js\n ** module id = 218\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react-hot-loader/~/react-hot-api/modules/makeMakeHot.js?");
|
||
|
||
/***/ },
|
||
/* 219 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("'use strict';\n\nvar makeAssimilatePrototype = __webpack_require__(220),\n requestForceUpdateAll = __webpack_require__(221);\n\nfunction hasNonStubTypeProperty(ReactClass) {\n if (!ReactClass.hasOwnProperty('type')) {\n return false;\n }\n\n var descriptor = Object.getOwnPropertyDescriptor(ReactClass, 'type');\n if (typeof descriptor.get === 'function') {\n return false;\n }\n\n return true;\n}\n\nfunction getPrototype(ReactClass) {\n var prototype = ReactClass.prototype,\n seemsLegit = prototype && typeof prototype.render === 'function';\n\n if (!seemsLegit && hasNonStubTypeProperty(ReactClass)) {\n prototype = ReactClass.type.prototype;\n }\n\n return prototype;\n}\n\n/**\n * Returns a function that will patch React class with new versions of itself\n * on subsequent invocations. Both legacy and ES6 style classes are supported.\n */\nmodule.exports = function makePatchReactClass(getRootInstances, React) {\n var assimilatePrototype = makeAssimilatePrototype(),\n FirstClass = null;\n\n return function patchReactClass(NextClass) {\n var nextPrototype = getPrototype(NextClass);\n assimilatePrototype(nextPrototype);\n\n if (FirstClass) {\n requestForceUpdateAll(getRootInstances, React);\n }\n\n return FirstClass || (FirstClass = NextClass);\n };\n};\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react-hot-loader/~/react-hot-api/modules/makePatchReactClass.js\n ** module id = 219\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react-hot-loader/~/react-hot-api/modules/makePatchReactClass.js?");
|
||
|
||
/***/ },
|
||
/* 220 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("'use strict';\n\n/**\n * Returns a function that establishes the first prototype passed to it\n * as the \"source of truth\" and patches its methods on subsequent invocations,\n * also patching current and previous prototypes to forward calls to it.\n */\nmodule.exports = function makeAssimilatePrototype() {\n var storedPrototype,\n knownPrototypes = [];\n\n function wrapMethod(key) {\n return function () {\n if (storedPrototype[key]) {\n return storedPrototype[key].apply(this, arguments);\n }\n };\n }\n\n function patchProperty(proto, key) {\n proto[key] = storedPrototype[key];\n\n if (typeof proto[key] !== 'function' ||\n key === 'type' ||\n key === 'constructor') {\n return;\n }\n\n proto[key] = wrapMethod(key);\n\n if (storedPrototype[key].isReactClassApproved) {\n proto[key].isReactClassApproved = storedPrototype[key].isReactClassApproved;\n }\n\n if (proto.__reactAutoBindMap && proto.__reactAutoBindMap[key]) {\n proto.__reactAutoBindMap[key] = proto[key];\n }\n }\n\n function updateStoredPrototype(freshPrototype) {\n storedPrototype = {};\n\n Object.getOwnPropertyNames(freshPrototype).forEach(function (key) {\n storedPrototype[key] = freshPrototype[key];\n });\n }\n\n function reconcileWithStoredPrototypes(freshPrototype) {\n knownPrototypes.push(freshPrototype);\n knownPrototypes.forEach(function (proto) {\n Object.getOwnPropertyNames(storedPrototype).forEach(function (key) {\n patchProperty(proto, key);\n });\n });\n }\n\n return function assimilatePrototype(freshPrototype) {\n if (Object.prototype.hasOwnProperty.call(freshPrototype, '__isAssimilatedByReactHotAPI')) {\n return;\n }\n\n updateStoredPrototype(freshPrototype);\n reconcileWithStoredPrototypes(freshPrototype);\n freshPrototype.__isAssimilatedByReactHotAPI = true;\n };\n};\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react-hot-loader/~/react-hot-api/modules/makeAssimilatePrototype.js\n ** module id = 220\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react-hot-loader/~/react-hot-api/modules/makeAssimilatePrototype.js?");
|
||
|
||
/***/ },
|
||
/* 221 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("var deepForceUpdate = __webpack_require__(222);\n\nvar isRequestPending = false;\n\nmodule.exports = function requestForceUpdateAll(getRootInstances, React) {\n if (isRequestPending) {\n return;\n }\n\n /**\n * Forces deep re-render of all mounted React components.\n * Hat's off to Omar Skalli (@Chetane) for suggesting this approach:\n * https://gist.github.com/Chetane/9a230a9fdcdca21a4e29\n */\n function forceUpdateAll() {\n isRequestPending = false;\n\n var rootInstances = getRootInstances(),\n rootInstance;\n\n for (var key in rootInstances) {\n if (rootInstances.hasOwnProperty(key)) {\n rootInstance = rootInstances[key];\n\n // `|| rootInstance` for React 0.12 and earlier\n rootInstance = rootInstance._reactInternalInstance || rootInstance;\n deepForceUpdate(rootInstance, React);\n }\n }\n }\n\n setTimeout(forceUpdateAll);\n};\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react-hot-loader/~/react-hot-api/modules/requestForceUpdateAll.js\n ** module id = 221\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react-hot-loader/~/react-hot-api/modules/requestForceUpdateAll.js?");
|
||
|
||
/***/ },
|
||
/* 222 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("'use strict';\n\nvar bindAutoBindMethods = __webpack_require__(223);\nvar traverseRenderedChildren = __webpack_require__(224);\n\nfunction setPendingForceUpdate(internalInstance) {\n if (internalInstance._pendingForceUpdate === false) {\n internalInstance._pendingForceUpdate = true;\n }\n}\n\nfunction forceUpdateIfPending(internalInstance, React) {\n if (internalInstance._pendingForceUpdate === true) {\n // `|| internalInstance` for React 0.12 and earlier\n var instance = internalInstance._instance || internalInstance;\n\n if (instance.forceUpdate) {\n instance.forceUpdate();\n } else if (React && React.Component) {\n React.Component.prototype.forceUpdate.call(instance);\n }\n }\n}\n\n/**\n * Updates a React component recursively, so even if children define funky\n * `shouldComponentUpdate`, they are forced to re-render.\n * Makes sure that any newly added methods are properly auto-bound.\n */\nfunction deepForceUpdate(internalInstance, React) {\n traverseRenderedChildren(internalInstance, bindAutoBindMethods);\n traverseRenderedChildren(internalInstance, setPendingForceUpdate);\n traverseRenderedChildren(internalInstance, forceUpdateIfPending, React);\n}\n\nmodule.exports = deepForceUpdate;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react-hot-loader/~/react-hot-api/modules/deepForceUpdate.js\n ** module id = 222\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react-hot-loader/~/react-hot-api/modules/deepForceUpdate.js?");
|
||
|
||
/***/ },
|
||
/* 223 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("'use strict';\n\nfunction bindAutoBindMethod(component, method) {\n var boundMethod = method.bind(component);\n\n boundMethod.__reactBoundContext = component;\n boundMethod.__reactBoundMethod = method;\n boundMethod.__reactBoundArguments = null;\n\n var componentName = component.constructor.displayName,\n _bind = boundMethod.bind;\n\n boundMethod.bind = function (newThis) {\n var args = Array.prototype.slice.call(arguments, 1);\n if (newThis !== component && newThis !== null) {\n console.warn(\n 'bind(): React component methods may only be bound to the ' +\n 'component instance. See ' + componentName\n );\n } else if (!args.length) {\n console.warn(\n 'bind(): You are binding a component method to the component. ' +\n 'React does this for you automatically in a high-performance ' +\n 'way, so you can safely remove this call. See ' + componentName\n );\n return boundMethod;\n }\n\n var reboundMethod = _bind.apply(boundMethod, arguments);\n reboundMethod.__reactBoundContext = component;\n reboundMethod.__reactBoundMethod = method;\n reboundMethod.__reactBoundArguments = args;\n\n return reboundMethod;\n };\n\n return boundMethod;\n}\n\n/**\n * Performs auto-binding similar to how React does it.\n * Skips already auto-bound methods.\n * Based on https://github.com/facebook/react/blob/b264372e2b3ad0b0c0c0cc95a2f383e4a1325c3d/src/classic/class/ReactClass.js#L639-L705\n */\nmodule.exports = function bindAutoBindMethods(internalInstance) {\n var component = typeof internalInstance.getPublicInstance === 'function' ?\n internalInstance.getPublicInstance() :\n internalInstance;\n\n for (var autoBindKey in component.__reactAutoBindMap) {\n if (!component.__reactAutoBindMap.hasOwnProperty(autoBindKey)) {\n continue;\n }\n\n // Skip already bound methods\n if (component.hasOwnProperty(autoBindKey) &&\n component[autoBindKey].__reactBoundContext === component) {\n continue;\n }\n\n var method = component.__reactAutoBindMap[autoBindKey];\n component[autoBindKey] = bindAutoBindMethod(component, method);\n }\n};\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react-hot-loader/~/react-hot-api/modules/bindAutoBindMethods.js\n ** module id = 223\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react-hot-loader/~/react-hot-api/modules/bindAutoBindMethods.js?");
|
||
|
||
/***/ },
|
||
/* 224 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("'use strict';\n\nfunction traverseRenderedChildren(internalInstance, callback, argument) {\n callback(internalInstance, argument);\n\n if (internalInstance._renderedComponent) {\n traverseRenderedChildren(\n internalInstance._renderedComponent,\n callback,\n argument\n );\n } else {\n for (var key in internalInstance._renderedChildren) {\n traverseRenderedChildren(\n internalInstance._renderedChildren[key],\n callback,\n argument\n );\n }\n }\n}\n\nmodule.exports = traverseRenderedChildren;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react-hot-loader/~/react-hot-api/modules/traverseRenderedChildren.js\n ** module id = 224\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react-hot-loader/~/react-hot-api/modules/traverseRenderedChildren.js?");
|
||
|
||
/***/ },
|
||
/* 225 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/* WEBPACK VAR INJECTION */(function(module) {/* REACT HOT LOADER */ if (true) { (function () { var ReactHotAPI = __webpack_require__(217), RootInstanceProvider = __webpack_require__(59), ReactMount = __webpack_require__(61), React = __webpack_require__(115); module.makeHot = module.hot.data ? module.hot.data.makeHot : ReactHotAPI(function () { return RootInstanceProvider.getRootInstances(ReactMount); }, React); })(); } (function () {\n\n'use strict';\n\nexports.__esModule = true;\n\nfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; }\n\nvar _react = __webpack_require__(115);\n\nvar _react2 = _interopRequireDefault(_react);\n\nvar _TodoApp = __webpack_require__(226);\n\nvar _TodoApp2 = _interopRequireDefault(_TodoApp);\n\nvar _redux = __webpack_require__(239);\n\nvar _reduxDevtools = __webpack_require__(263);\n\nvar _reduxDevtoolsLibReact = __webpack_require__(266);\n\nvar _reactRedux = __webpack_require__(227);\n\nvar _reducers = __webpack_require__(294);\n\nvar reducers = _interopRequireWildcard(_reducers);\n\nvar finalCreateStore = _redux.compose(_reduxDevtools.devTools(), _reduxDevtools.persistState(window.location.href.match(/[?&]debug_session=([^&]+)\\b/)), _redux.createStore);\n\nvar reducer = _redux.combineReducers(reducers);\nvar store = finalCreateStore(reducer);\n\nvar App = (function (_Component) {\n _inherits(App, _Component);\n\n function App() {\n _classCallCheck(this, App);\n\n _Component.apply(this, arguments);\n }\n\n App.prototype.render = function render() {\n return _react2['default'].createElement(\n 'div',\n null,\n _react2['default'].createElement(\n _reactRedux.Provider,\n { store: store },\n function () {\n return _react2['default'].createElement(_TodoApp2['default'], null);\n }\n ),\n _react2['default'].createElement(\n _reduxDevtoolsLibReact.DebugPanel,\n { top: true, right: true, bottom: true },\n _react2['default'].createElement(_reduxDevtoolsLibReact.DevTools, { store: store,\n monitor: _reduxDevtoolsLibReact.LogMonitor })\n )\n );\n };\n\n return App;\n})(_react.Component);\n\nexports['default'] = App;\nmodule.exports = exports['default'];\n\n/* REACT HOT LOADER */ }).call(this); if (true) { (function () { module.hot.dispose(function (data) { data.makeHot = module.makeHot; }); if (module.exports && module.makeHot) { var makeExportsHot = __webpack_require__(254), foundReactClasses = false; if (makeExportsHot(module, __webpack_require__(115))) { foundReactClasses = true; } var shouldAcceptModule = true && foundReactClasses; if (shouldAcceptModule) { module.hot.accept(function (err) { if (err) { console.error(\"Cannot not apply hot update to \" + \"App.js\" + \": \" + err.message); } }); } } })(); }\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(34)(module)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./containers/App.js\n ** module id = 225\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./containers/App.js?");
|
||
|
||
/***/ },
|
||
/* 226 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/* WEBPACK VAR INJECTION */(function(module) {/* REACT HOT LOADER */ if (true) { (function () { var ReactHotAPI = __webpack_require__(217), RootInstanceProvider = __webpack_require__(59), ReactMount = __webpack_require__(61), React = __webpack_require__(115); module.makeHot = module.hot.data ? module.hot.data.makeHot : ReactHotAPI(function () { return RootInstanceProvider.getRootInstances(ReactMount); }, React); })(); } (function () {\n\n'use strict';\n\nexports.__esModule = true;\n\nfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; }\n\nvar _react = __webpack_require__(115);\n\nvar _react2 = _interopRequireDefault(_react);\n\nvar _redux = __webpack_require__(239);\n\nvar _reactRedux = __webpack_require__(227);\n\nvar _componentsHeader = __webpack_require__(251);\n\nvar _componentsHeader2 = _interopRequireDefault(_componentsHeader);\n\nvar _componentsMainSection = __webpack_require__(257);\n\nvar _componentsMainSection2 = _interopRequireDefault(_componentsMainSection);\n\nvar _actionsTodoActions = __webpack_require__(261);\n\nvar TodoActions = _interopRequireWildcard(_actionsTodoActions);\n\nvar TodoApp = (function (_Component) {\n _inherits(TodoApp, _Component);\n\n function TodoApp() {\n _classCallCheck(this, TodoApp);\n\n _Component.apply(this, arguments);\n }\n\n TodoApp.prototype.render = function render() {\n return _react2['default'].createElement(\n _reactRedux.Connector,\n { select: function (state) {\n return { todos: state.todos };\n } },\n this.renderChild\n );\n };\n\n TodoApp.prototype.renderChild = function renderChild(_ref) {\n var todos = _ref.todos;\n var dispatch = _ref.dispatch;\n\n var actions = _redux.bindActionCreators(TodoActions, dispatch);\n return _react2['default'].createElement(\n 'div',\n null,\n _react2['default'].createElement(_componentsHeader2['default'], { addTodo: actions.addTodo }),\n _react2['default'].createElement(_componentsMainSection2['default'], { todos: todos, actions: actions })\n );\n };\n\n return TodoApp;\n})(_react.Component);\n\nexports['default'] = TodoApp;\nmodule.exports = exports['default'];\n\n/* REACT HOT LOADER */ }).call(this); if (true) { (function () { module.hot.dispose(function (data) { data.makeHot = module.makeHot; }); if (module.exports && module.makeHot) { var makeExportsHot = __webpack_require__(254), foundReactClasses = false; if (makeExportsHot(module, __webpack_require__(115))) { foundReactClasses = true; } var shouldAcceptModule = true && foundReactClasses; if (shouldAcceptModule) { module.hot.accept(function (err) { if (err) { console.error(\"Cannot not apply hot update to \" + \"TodoApp.js\" + \": \" + err.message); } }); } } })(); }\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(34)(module)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./containers/TodoApp.js\n ** module id = 226\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./containers/TodoApp.js?");
|
||
|
||
/***/ },
|
||
/* 227 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("'use strict';\n\nexports.__esModule = true;\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nvar _react = __webpack_require__(115);\n\nvar _react2 = _interopRequireDefault(_react);\n\nvar _componentsCreateAll = __webpack_require__(228);\n\nvar _componentsCreateAll2 = _interopRequireDefault(_componentsCreateAll);\n\nvar _createAll = _componentsCreateAll2['default'](_react2['default']);\n\nvar Provider = _createAll.Provider;\nvar Connector = _createAll.Connector;\nvar provide = _createAll.provide;\nvar connect = _createAll.connect;\nexports.Provider = Provider;\nexports.Connector = Connector;\nexports.provide = provide;\nexports.connect = connect;\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react-redux/lib/index.js\n ** module id = 227\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react-redux/lib/index.js?");
|
||
|
||
/***/ },
|
||
/* 228 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("'use strict';\n\nexports.__esModule = true;\nexports['default'] = createAll;\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nvar _createProvider = __webpack_require__(229);\n\nvar _createProvider2 = _interopRequireDefault(_createProvider);\n\nvar _createProvideDecorator = __webpack_require__(231);\n\nvar _createProvideDecorator2 = _interopRequireDefault(_createProvideDecorator);\n\nvar _createConnector = __webpack_require__(233);\n\nvar _createConnector2 = _interopRequireDefault(_createConnector);\n\nvar _createConnectDecorator = __webpack_require__(237);\n\nvar _createConnectDecorator2 = _interopRequireDefault(_createConnectDecorator);\n\nfunction createAll(React) {\n // Wrapper components\n var Provider = _createProvider2['default'](React);\n var Connector = _createConnector2['default'](React);\n\n // Higher-order components (decorators)\n var provide = _createProvideDecorator2['default'](React, Provider);\n var connect = _createConnectDecorator2['default'](React, Connector);\n\n return { Provider: Provider, Connector: Connector, provide: provide, connect: connect };\n}\n\nmodule.exports = exports['default'];\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react-redux/lib/components/createAll.js\n ** module id = 228\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react-redux/lib/components/createAll.js?");
|
||
|
||
/***/ },
|
||
/* 229 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("'use strict';\n\nexports.__esModule = true;\n\nvar _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();\n\nexports['default'] = createProvider;\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; }\n\nvar _utilsCreateStoreShape = __webpack_require__(230);\n\nvar _utilsCreateStoreShape2 = _interopRequireDefault(_utilsCreateStoreShape);\n\nfunction createProvider(React) {\n var Component = React.Component;\n var PropTypes = React.PropTypes;\n\n var storeShape = _utilsCreateStoreShape2['default'](PropTypes);\n\n return (function (_Component) {\n function Provider(props, context) {\n _classCallCheck(this, Provider);\n\n _Component.call(this, props, context);\n this.state = { store: props.store };\n }\n\n _inherits(Provider, _Component);\n\n Provider.prototype.getChildContext = function getChildContext() {\n return { store: this.state.store };\n };\n\n Provider.prototype.componentWillReceiveProps = function componentWillReceiveProps(nextProps) {\n var store = this.state.store;\n var nextStore = nextProps.store;\n\n if (store !== nextStore) {\n var nextReducer = nextStore.getReducer();\n store.replaceReducer(nextReducer);\n }\n };\n\n Provider.prototype.render = function render() {\n var children = this.props.children;\n\n return children();\n };\n\n _createClass(Provider, null, [{\n key: 'childContextTypes',\n value: {\n store: storeShape.isRequired\n },\n enumerable: true\n }, {\n key: 'propTypes',\n value: {\n children: PropTypes.func.isRequired\n },\n enumerable: true\n }]);\n\n return Provider;\n })(Component);\n}\n\nmodule.exports = exports['default'];\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react-redux/lib/components/createProvider.js\n ** module id = 229\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react-redux/lib/components/createProvider.js?");
|
||
|
||
/***/ },
|
||
/* 230 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("\"use strict\";\n\nexports.__esModule = true;\nexports[\"default\"] = createStoreShape;\n\nfunction createStoreShape(PropTypes) {\n return PropTypes.shape({\n subscribe: PropTypes.func.isRequired,\n dispatch: PropTypes.func.isRequired,\n getState: PropTypes.func.isRequired\n });\n}\n\nmodule.exports = exports[\"default\"];\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react-redux/lib/utils/createStoreShape.js\n ** module id = 230\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react-redux/lib/utils/createStoreShape.js?");
|
||
|
||
/***/ },
|
||
/* 231 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("'use strict';\n\nexports.__esModule = true;\n\nvar _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();\n\nexports['default'] = createProvideDecorator;\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; }\n\nvar _utilsGetDisplayName = __webpack_require__(232);\n\nvar _utilsGetDisplayName2 = _interopRequireDefault(_utilsGetDisplayName);\n\nfunction createProvideDecorator(React, Provider) {\n var Component = React.Component;\n\n return function provide(store) {\n return function (DecoratedComponent) {\n return (function (_Component) {\n function ProviderDecorator() {\n _classCallCheck(this, ProviderDecorator);\n\n _Component.apply(this, arguments);\n }\n\n _inherits(ProviderDecorator, _Component);\n\n ProviderDecorator.prototype.render = function render() {\n var _this = this;\n\n return React.createElement(\n Provider,\n { store: store },\n function () {\n return React.createElement(DecoratedComponent, _this.props);\n }\n );\n };\n\n _createClass(ProviderDecorator, null, [{\n key: 'displayName',\n value: 'Provider(' + _utilsGetDisplayName2['default'](DecoratedComponent) + ')',\n enumerable: true\n }, {\n key: 'DecoratedComponent',\n value: DecoratedComponent,\n enumerable: true\n }]);\n\n return ProviderDecorator;\n })(Component);\n };\n };\n}\n\nmodule.exports = exports['default'];\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react-redux/lib/components/createProvideDecorator.js\n ** module id = 231\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react-redux/lib/components/createProvideDecorator.js?");
|
||
|
||
/***/ },
|
||
/* 232 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("'use strict';\n\nexports.__esModule = true;\nexports['default'] = getDisplayName;\n\nfunction getDisplayName(Component) {\n return Component.displayName || Component.name || 'Component';\n}\n\nmodule.exports = exports['default'];\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react-redux/lib/utils/getDisplayName.js\n ** module id = 232\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react-redux/lib/utils/getDisplayName.js?");
|
||
|
||
/***/ },
|
||
/* 233 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("'use strict';\n\nexports.__esModule = true;\n\nvar _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; };\n\nvar _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();\n\nexports['default'] = createConnector;\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; }\n\nvar _utilsCreateStoreShape = __webpack_require__(230);\n\nvar _utilsCreateStoreShape2 = _interopRequireDefault(_utilsCreateStoreShape);\n\nvar _utilsShallowEqual = __webpack_require__(234);\n\nvar _utilsShallowEqual2 = _interopRequireDefault(_utilsShallowEqual);\n\nvar _utilsIsPlainObject = __webpack_require__(235);\n\nvar _utilsIsPlainObject2 = _interopRequireDefault(_utilsIsPlainObject);\n\nvar _invariant = __webpack_require__(236);\n\nvar _invariant2 = _interopRequireDefault(_invariant);\n\nfunction createConnector(React) {\n var Component = React.Component;\n var PropTypes = React.PropTypes;\n\n var storeShape = _utilsCreateStoreShape2['default'](PropTypes);\n\n return (function (_Component) {\n function Connector(props, context) {\n _classCallCheck(this, Connector);\n\n _Component.call(this, props, context);\n this.state = this.selectState(props, context);\n }\n\n _inherits(Connector, _Component);\n\n Connector.prototype.shouldComponentUpdate = function shouldComponentUpdate(nextProps, nextState) {\n return !this.isSliceEqual(this.state.slice, nextState.slice) || !_utilsShallowEqual2['default'](this.props, nextProps);\n };\n\n Connector.prototype.isSliceEqual = function isSliceEqual(slice, nextSlice) {\n var isRefEqual = slice === nextSlice;\n if (isRefEqual) {\n return true;\n } else if (typeof slice !== 'object' || typeof nextSlice !== 'object') {\n return isRefEqual;\n }\n return _utilsShallowEqual2['default'](slice, nextSlice);\n };\n\n Connector.prototype.componentDidMount = function componentDidMount() {\n this.unsubscribe = this.context.store.subscribe(this.handleChange.bind(this));\n this.handleChange();\n };\n\n Connector.prototype.componentWillReceiveProps = function componentWillReceiveProps(nextProps) {\n if (nextProps.select !== this.props.select) {\n // Force the state slice recalculation\n this.handleChange(nextProps);\n }\n };\n\n Connector.prototype.componentWillUnmount = function componentWillUnmount() {\n this.unsubscribe();\n };\n\n Connector.prototype.handleChange = function handleChange() {\n var props = arguments[0] === undefined ? this.props : arguments[0];\n\n var nextState = this.selectState(props, this.context);\n if (!this.isSliceEqual(this.state.slice, nextState.slice)) {\n this.setState(nextState);\n }\n };\n\n Connector.prototype.selectState = function selectState(props, context) {\n var state = context.store.getState();\n var slice = props.select(state);\n\n _invariant2['default'](_utilsIsPlainObject2['default'](slice), 'The return value of `select` prop must be an object. Instead received %s.', slice);\n\n return { slice: slice };\n };\n\n Connector.prototype.render = function render() {\n var children = this.props.children;\n var slice = this.state.slice;\n var dispatch = this.context.store.dispatch;\n\n return children(_extends({ dispatch: dispatch }, slice));\n };\n\n _createClass(Connector, null, [{\n key: 'contextTypes',\n value: {\n store: storeShape.isRequired\n },\n enumerable: true\n }, {\n key: 'propTypes',\n value: {\n children: PropTypes.func.isRequired,\n select: PropTypes.func.isRequired\n },\n enumerable: true\n }, {\n key: 'defaultProps',\n value: {\n select: function select(state) {\n return state;\n }\n },\n enumerable: true\n }]);\n\n return Connector;\n })(Component);\n}\n\nmodule.exports = exports['default'];\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react-redux/lib/components/createConnector.js\n ** module id = 233\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react-redux/lib/components/createConnector.js?");
|
||
|
||
/***/ },
|
||
/* 234 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("\"use strict\";\n\nexports.__esModule = true;\nexports[\"default\"] = shallowEqual;\n\nfunction shallowEqual(objA, objB) {\n if (objA === objB) {\n return true;\n }\n\n var keysA = Object.keys(objA);\n var keysB = Object.keys(objB);\n\n if (keysA.length !== keysB.length) {\n return false;\n }\n\n // Test for A's keys different from B.\n var hasOwn = Object.prototype.hasOwnProperty;\n for (var i = 0; i < keysA.length; i++) {\n if (!hasOwn.call(objB, keysA[i]) || objA[keysA[i]] !== objB[keysA[i]]) {\n return false;\n }\n }\n\n return true;\n}\n\nmodule.exports = exports[\"default\"];\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react-redux/lib/utils/shallowEqual.js\n ** module id = 234\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react-redux/lib/utils/shallowEqual.js?");
|
||
|
||
/***/ },
|
||
/* 235 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("'use strict';\n\nexports.__esModule = true;\nexports['default'] = isPlainObject;\n\nfunction isPlainObject(obj) {\n return obj ? typeof obj === 'object' && Object.getPrototypeOf(obj) === Object.prototype : false;\n}\n\nmodule.exports = exports['default'];\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react-redux/lib/utils/isPlainObject.js\n ** module id = 235\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react-redux/lib/utils/isPlainObject.js?");
|
||
|
||
/***/ },
|
||
/* 236 */
|
||
/***/ 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 invariant\n */\n\n'use strict';\n\n/**\n * Use invariant() to assert state which your program assumes to be true.\n *\n * Provide sprintf-style format (only %s is supported) and arguments\n * to provide information about what broke and what you were\n * expecting.\n *\n * The invariant message will be stripped in production, but the invariant\n * will remain to ensure logic does not differ in production.\n */\n\nvar invariant = function(condition, format, a, b, c, d, e, f) {\n if (process.env.NODE_ENV !== 'production') {\n if (format === undefined) {\n throw new Error('invariant requires an error message argument');\n }\n }\n\n if (!condition) {\n var error;\n if (format === undefined) {\n error = new Error(\n 'Minified exception occurred; use the non-minified dev environment ' +\n 'for the full error message and additional helpful warnings.'\n );\n } else {\n var args = [a, b, c, d, e, f];\n var argIndex = 0;\n error = new Error(\n 'Invariant Violation: ' +\n format.replace(/%s/g, function() { return args[argIndex++]; })\n );\n }\n\n error.framesToPop = 1; // we don't care about invariant's own frame\n throw error;\n }\n};\n\nmodule.exports = invariant;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react-redux/~/invariant/browser.js\n ** module id = 236\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react-redux/~/invariant/browser.js?");
|
||
|
||
/***/ },
|
||
/* 237 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("'use strict';\n\nexports.__esModule = true;\n\nvar _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; };\n\nvar _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();\n\nexports['default'] = createConnectDecorator;\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; }\n\nvar _utilsGetDisplayName = __webpack_require__(232);\n\nvar _utilsGetDisplayName2 = _interopRequireDefault(_utilsGetDisplayName);\n\nvar _utilsShallowEqualScalar = __webpack_require__(238);\n\nvar _utilsShallowEqualScalar2 = _interopRequireDefault(_utilsShallowEqualScalar);\n\nfunction createConnectDecorator(React, Connector) {\n var Component = React.Component;\n\n return function connect(select) {\n return function (DecoratedComponent) {\n return (function (_Component) {\n function ConnectorDecorator() {\n _classCallCheck(this, ConnectorDecorator);\n\n _Component.apply(this, arguments);\n }\n\n _inherits(ConnectorDecorator, _Component);\n\n ConnectorDecorator.prototype.shouldComponentUpdate = function shouldComponentUpdate(nextProps) {\n return !_utilsShallowEqualScalar2['default'](this.props, nextProps);\n };\n\n ConnectorDecorator.prototype.render = function render() {\n var _this = this;\n\n return React.createElement(\n Connector,\n { select: function (state) {\n return select(state, _this.props);\n } },\n function (stuff) {\n return React.createElement(DecoratedComponent, _extends({}, stuff, _this.props));\n }\n );\n };\n\n _createClass(ConnectorDecorator, null, [{\n key: 'displayName',\n value: 'Connector(' + _utilsGetDisplayName2['default'](DecoratedComponent) + ')',\n enumerable: true\n }, {\n key: 'DecoratedComponent',\n value: DecoratedComponent,\n enumerable: true\n }]);\n\n return ConnectorDecorator;\n })(Component);\n };\n };\n}\n\nmodule.exports = exports['default'];\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react-redux/lib/components/createConnectDecorator.js\n ** module id = 237\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react-redux/lib/components/createConnectDecorator.js?");
|
||
|
||
/***/ },
|
||
/* 238 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("'use strict';\n\nexports.__esModule = true;\nexports['default'] = shallowEqualScalar;\n\nfunction shallowEqualScalar(objA, objB) {\n if (objA === objB) {\n return true;\n }\n\n if (typeof objA !== 'object' || objA === null || typeof objB !== 'object' || objB === null) {\n return false;\n }\n\n var keysA = Object.keys(objA);\n var keysB = Object.keys(objB);\n\n if (keysA.length !== keysB.length) {\n return false;\n }\n\n // Test for A's keys different from B.\n var hasOwn = Object.prototype.hasOwnProperty;\n for (var i = 0; i < keysA.length; i++) {\n if (!hasOwn.call(objB, keysA[i])) {\n return false;\n }\n\n var valA = objA[keysA[i]];\n var valB = objB[keysA[i]];\n\n if (valA !== valB || typeof valA === 'object' || typeof valB === 'object') {\n return false;\n }\n }\n\n return true;\n}\n\nmodule.exports = exports['default'];\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react-redux/lib/utils/shallowEqualScalar.js\n ** module id = 238\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react-redux/lib/utils/shallowEqualScalar.js?");
|
||
|
||
/***/ },
|
||
/* 239 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("// Core\n'use strict';\n\nexports.__esModule = true;\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nvar _createStore = __webpack_require__(242);\n\nvar _createStore2 = _interopRequireDefault(_createStore);\n\n// Utilities\n\nvar _utilsCompose = __webpack_require__(246);\n\nvar _utilsCompose2 = _interopRequireDefault(_utilsCompose);\n\nvar _utilsCombineReducers = __webpack_require__(247);\n\nvar _utilsCombineReducers2 = _interopRequireDefault(_utilsCombineReducers);\n\nvar _utilsBindActionCreators = __webpack_require__(240);\n\nvar _utilsBindActionCreators2 = _interopRequireDefault(_utilsBindActionCreators);\n\nvar _utilsApplyMiddleware = __webpack_require__(249);\n\nvar _utilsApplyMiddleware2 = _interopRequireDefault(_utilsApplyMiddleware);\n\nvar _utilsComposeMiddleware = __webpack_require__(250);\n\nvar _utilsComposeMiddleware2 = _interopRequireDefault(_utilsComposeMiddleware);\n\nexports.createStore = _createStore2['default'];\nexports.compose = _utilsCompose2['default'];\nexports.combineReducers = _utilsCombineReducers2['default'];\nexports.bindActionCreators = _utilsBindActionCreators2['default'];\nexports.applyMiddleware = _utilsApplyMiddleware2['default'];\nexports.composeMiddleware = _utilsComposeMiddleware2['default'];\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/redux/lib/index.js\n ** module id = 239\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/redux/lib/index.js?");
|
||
|
||
/***/ },
|
||
/* 240 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("'use strict';\n\nexports.__esModule = true;\nexports['default'] = bindActionCreators;\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nvar _utilsMapValues = __webpack_require__(241);\n\nvar _utilsMapValues2 = _interopRequireDefault(_utilsMapValues);\n\nfunction bindActionCreators(actionCreators, dispatch) {\n return _utilsMapValues2['default'](actionCreators, function (actionCreator) {\n return function () {\n return dispatch(actionCreator.apply(undefined, arguments));\n };\n });\n}\n\nmodule.exports = exports['default'];\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/redux/lib/utils/bindActionCreators.js\n ** module id = 240\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/redux/lib/utils/bindActionCreators.js?");
|
||
|
||
/***/ },
|
||
/* 241 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("\"use strict\";\n\nexports.__esModule = true;\nexports[\"default\"] = mapValues;\n\nfunction mapValues(obj, fn) {\n return Object.keys(obj).reduce(function (result, key) {\n result[key] = fn(obj[key], key);\n return result;\n }, {});\n}\n\nmodule.exports = exports[\"default\"];\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/redux/lib/utils/mapValues.js\n ** module id = 241\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/redux/lib/utils/mapValues.js?");
|
||
|
||
/***/ },
|
||
/* 242 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("'use strict';\n\nexports.__esModule = true;\nexports['default'] = createStore;\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nvar _Store = __webpack_require__(243);\n\nvar _Store2 = _interopRequireDefault(_Store);\n\nfunction createStore(reducer, initialState) {\n var store = new _Store2['default'](reducer, initialState);\n\n return {\n dispatch: store.dispatch.bind(store),\n subscribe: store.subscribe.bind(store),\n getState: store.getState.bind(store),\n getReducer: store.getReducer.bind(store),\n replaceReducer: store.replaceReducer.bind(store)\n };\n}\n\nmodule.exports = exports['default'];\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/redux/lib/createStore.js\n ** module id = 242\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/redux/lib/createStore.js?");
|
||
|
||
/***/ },
|
||
/* 243 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("'use strict';\n\nexports.__esModule = true;\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }\n\nvar _invariant = __webpack_require__(244);\n\nvar _invariant2 = _interopRequireDefault(_invariant);\n\nvar _utilsIsPlainObject = __webpack_require__(245);\n\nvar _utilsIsPlainObject2 = _interopRequireDefault(_utilsIsPlainObject);\n\n// Don't ever try to handle these action types in your code. They are private.\n// For any unknown actions, you must return the current state.\n// If the current state is undefined, you must return the initial state.\nvar ActionTypes = {\n INIT: '@@redux/INIT'\n};\n\nexports.ActionTypes = ActionTypes;\n\nvar Store = (function () {\n function Store(reducer, initialState) {\n _classCallCheck(this, Store);\n\n _invariant2['default'](typeof reducer === 'function', 'Expected the reducer to be a function.');\n\n this.state = initialState;\n this.listeners = [];\n this.replaceReducer(reducer);\n }\n\n Store.prototype.getReducer = function getReducer() {\n return this.reducer;\n };\n\n Store.prototype.replaceReducer = function replaceReducer(nextReducer) {\n this.reducer = nextReducer;\n this.dispatch({ type: ActionTypes.INIT });\n };\n\n Store.prototype.dispatch = function dispatch(action) {\n _invariant2['default'](_utilsIsPlainObject2['default'](action), 'Actions must be plain objects. Use custom middleware for async actions.');\n\n var reducer = this.reducer;\n\n this.state = reducer(this.state, action);\n this.listeners.forEach(function (listener) {\n return listener();\n });\n return action;\n };\n\n Store.prototype.getState = function getState() {\n return this.state;\n };\n\n Store.prototype.subscribe = function subscribe(listener) {\n var listeners = this.listeners;\n\n listeners.push(listener);\n\n return function unsubscribe() {\n var index = listeners.indexOf(listener);\n listeners.splice(index, 1);\n };\n };\n\n return Store;\n})();\n\nexports['default'] = Store;\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/redux/lib/Store.js\n ** module id = 243\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/redux/lib/Store.js?");
|
||
|
||
/***/ },
|
||
/* 244 */
|
||
/***/ 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 invariant\n */\n\n'use strict';\n\n/**\n * Use invariant() to assert state which your program assumes to be true.\n *\n * Provide sprintf-style format (only %s is supported) and arguments\n * to provide information about what broke and what you were\n * expecting.\n *\n * The invariant message will be stripped in production, but the invariant\n * will remain to ensure logic does not differ in production.\n */\n\nvar invariant = function(condition, format, a, b, c, d, e, f) {\n if (process.env.NODE_ENV !== 'production') {\n if (format === undefined) {\n throw new Error('invariant requires an error message argument');\n }\n }\n\n if (!condition) {\n var error;\n if (format === undefined) {\n error = new Error(\n 'Minified exception occurred; use the non-minified dev environment ' +\n 'for the full error message and additional helpful warnings.'\n );\n } else {\n var args = [a, b, c, d, e, f];\n var argIndex = 0;\n error = new Error(\n 'Invariant Violation: ' +\n format.replace(/%s/g, function() { return args[argIndex++]; })\n );\n }\n\n error.framesToPop = 1; // we don't care about invariant's own frame\n throw error;\n }\n};\n\nmodule.exports = invariant;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/redux/~/invariant/browser.js\n ** module id = 244\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/redux/~/invariant/browser.js?");
|
||
|
||
/***/ },
|
||
/* 245 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("'use strict';\n\nexports.__esModule = true;\nexports['default'] = isPlainObject;\n\nfunction isPlainObject(obj) {\n return obj ? typeof obj === 'object' && Object.getPrototypeOf(obj) === Object.prototype : false;\n}\n\nmodule.exports = exports['default'];\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/redux/lib/utils/isPlainObject.js\n ** module id = 245\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/redux/lib/utils/isPlainObject.js?");
|
||
|
||
/***/ },
|
||
/* 246 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("/**\n * Composes functions from left to right\n * @param {...Function} funcs - Functions to compose\n * @return {Function}\n */\n\"use strict\";\n\nexports.__esModule = true;\nexports[\"default\"] = compose;\n\nfunction compose() {\n for (var _len = arguments.length, funcs = Array(_len), _key = 0; _key < _len; _key++) {\n funcs[_key] = arguments[_key];\n }\n\n return funcs.reduceRight(function (composed, f) {\n return f(composed);\n });\n}\n\nmodule.exports = exports[\"default\"];\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/redux/lib/utils/compose.js\n ** module id = 246\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/redux/lib/utils/compose.js?");
|
||
|
||
/***/ },
|
||
/* 247 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("'use strict';\n\nexports.__esModule = true;\nexports['default'] = combineReducers;\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nvar _utilsMapValues = __webpack_require__(241);\n\nvar _utilsMapValues2 = _interopRequireDefault(_utilsMapValues);\n\nvar _utilsPick = __webpack_require__(248);\n\nvar _utilsPick2 = _interopRequireDefault(_utilsPick);\n\nvar _invariant = __webpack_require__(244);\n\nvar _invariant2 = _interopRequireDefault(_invariant);\n\nvar _Store = __webpack_require__(243);\n\nfunction getErrorMessage(key, action) {\n var actionType = action && action.type;\n var actionName = actionType && '\"' + actionType + '\"' || 'an action';\n\n return 'Reducer \"' + key + '\" returned undefined handling ' + actionName + '. ' + 'To ignore an action, you must explicitly return the previous state.';\n}\n\nfunction combineReducers(reducers) {\n var finalReducers = _utilsPick2['default'](reducers, function (val) {\n return typeof val === 'function';\n });\n\n Object.keys(finalReducers).forEach(function (key) {\n var reducer = finalReducers[key];\n _invariant2['default'](typeof reducer(undefined, { type: _Store.ActionTypes.INIT }) !== 'undefined', 'Reducer \"' + key + '\" returned undefined during initialization. ' + 'If the state passed to the reducer is undefined, you must ' + 'explicitly return the initial state. The initial state may ' + 'not be undefined.');\n\n var type = Math.random().toString(36).substring(7).split('').join('.');\n _invariant2['default'](typeof reducer(undefined, { type: type }) !== 'undefined', 'Reducer \"' + key + '\" returned undefined when probed with a random type. ' + ('Don\\'t try to handle ' + _Store.ActionTypes.INIT + ' or other actions in \"redux/*\" ') + 'namespace. They are considered private. Instead, you must return the ' + 'current state for any unknown actions, unless it is undefined, ' + 'in which case you must return the initial state, regardless of the ' + 'action type. The initial state may not be undefined.');\n });\n\n return function composition(state, action) {\n if (state === undefined) state = {};\n\n return _utilsMapValues2['default'](finalReducers, function (reducer, key) {\n var newState = reducer(state[key], action);\n _invariant2['default'](typeof newState !== 'undefined', getErrorMessage(key, action));\n return newState;\n });\n };\n}\n\nmodule.exports = exports['default'];\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/redux/lib/utils/combineReducers.js\n ** module id = 247\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/redux/lib/utils/combineReducers.js?");
|
||
|
||
/***/ },
|
||
/* 248 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("\"use strict\";\n\nexports.__esModule = true;\nexports[\"default\"] = pick;\n\nfunction pick(obj, fn) {\n return Object.keys(obj).reduce(function (result, key) {\n if (fn(obj[key])) {\n result[key] = obj[key];\n }\n return result;\n }, {});\n}\n\nmodule.exports = exports[\"default\"];\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/redux/lib/utils/pick.js\n ** module id = 248\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/redux/lib/utils/pick.js?");
|
||
|
||
/***/ },
|
||
/* 249 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("'use strict';\n\nexports.__esModule = true;\n\nvar _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; };\n\nexports['default'] = applyMiddleware;\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nvar _compose = __webpack_require__(246);\n\nvar _compose2 = _interopRequireDefault(_compose);\n\nvar _composeMiddleware = __webpack_require__(250);\n\nvar _composeMiddleware2 = _interopRequireDefault(_composeMiddleware);\n\n/**\n * Creates a higher-order store that applies middleware to a store's dispatch.\n * Because middleware is potentially asynchronous, this should be the first\n * higher-order store in the composition chain.\n * @param {...Function} ...middlewares\n * @return {Function} A higher-order store\n */\n\nfunction applyMiddleware() {\n for (var _len = arguments.length, middlewares = Array(_len), _key = 0; _key < _len; _key++) {\n middlewares[_key] = arguments[_key];\n }\n\n return function (next) {\n return function () {\n var store = next.apply(undefined, arguments);\n var middleware = _composeMiddleware2['default'].apply(undefined, middlewares);\n\n function dispatch(action) {\n var methods = {\n dispatch: dispatch,\n getState: store.getState\n };\n\n return _compose2['default'](middleware(methods), store.dispatch)(action);\n }\n\n return _extends({}, store, {\n dispatch: dispatch\n });\n };\n };\n}\n\nmodule.exports = exports['default'];\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/redux/lib/utils/applyMiddleware.js\n ** module id = 249\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/redux/lib/utils/applyMiddleware.js?");
|
||
|
||
/***/ },
|
||
/* 250 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("'use strict';\n\nexports.__esModule = true;\nexports['default'] = composeMiddleware;\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nvar _compose = __webpack_require__(246);\n\nvar _compose2 = _interopRequireDefault(_compose);\n\n/**\n * Compose middleware from left to right\n * @param {...Function} middlewares\n * @return {Function}\n */\n\nfunction composeMiddleware() {\n for (var _len = arguments.length, middlewares = Array(_len), _key = 0; _key < _len; _key++) {\n middlewares[_key] = arguments[_key];\n }\n\n return function (methods) {\n return function (next) {\n return _compose2['default'].apply(undefined, middlewares.map(function (m) {\n return m(methods);\n }).concat([next]));\n };\n };\n}\n\nmodule.exports = exports['default'];\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/redux/lib/utils/composeMiddleware.js\n ** module id = 250\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/redux/lib/utils/composeMiddleware.js?");
|
||
|
||
/***/ },
|
||
/* 251 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/* WEBPACK VAR INJECTION */(function(module) {/* REACT HOT LOADER */ if (true) { (function () { var ReactHotAPI = __webpack_require__(217), RootInstanceProvider = __webpack_require__(59), ReactMount = __webpack_require__(61), React = __webpack_require__(115); module.makeHot = module.hot.data ? module.hot.data.makeHot : ReactHotAPI(function () { return RootInstanceProvider.getRootInstances(ReactMount); }, React); })(); } (function () {\n\n'use strict';\n\nexports.__esModule = true;\n\nvar _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; }\n\nvar _react = __webpack_require__(115);\n\nvar _react2 = _interopRequireDefault(_react);\n\nvar _TodoTextInput = __webpack_require__(252);\n\nvar _TodoTextInput2 = _interopRequireDefault(_TodoTextInput);\n\nvar Header = (function (_Component) {\n _inherits(Header, _Component);\n\n function Header() {\n _classCallCheck(this, Header);\n\n _Component.apply(this, arguments);\n }\n\n Header.prototype.handleSave = function handleSave(text) {\n if (text.length !== 0) {\n this.props.addTodo(text);\n }\n };\n\n Header.prototype.render = function render() {\n return _react2['default'].createElement(\n 'header',\n { className: 'header' },\n _react2['default'].createElement(\n 'h1',\n null,\n 'todos'\n ),\n _react2['default'].createElement(_TodoTextInput2['default'], { newTodo: true,\n onSave: this.handleSave.bind(this),\n placeholder: 'What needs to be done?' })\n );\n };\n\n _createClass(Header, null, [{\n key: 'propTypes',\n value: {\n addTodo: _react.PropTypes.func.isRequired\n },\n enumerable: true\n }]);\n\n return Header;\n})(_react.Component);\n\nexports['default'] = Header;\nmodule.exports = exports['default'];\n\n/* REACT HOT LOADER */ }).call(this); if (true) { (function () { module.hot.dispose(function (data) { data.makeHot = module.makeHot; }); if (module.exports && module.makeHot) { var makeExportsHot = __webpack_require__(254), foundReactClasses = false; if (makeExportsHot(module, __webpack_require__(115))) { foundReactClasses = true; } var shouldAcceptModule = true && foundReactClasses; if (shouldAcceptModule) { module.hot.accept(function (err) { if (err) { console.error(\"Cannot not apply hot update to \" + \"Header.js\" + \": \" + err.message); } }); } } })(); }\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(34)(module)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./components/Header.js\n ** module id = 251\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./components/Header.js?");
|
||
|
||
/***/ },
|
||
/* 252 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/* WEBPACK VAR INJECTION */(function(module) {/* REACT HOT LOADER */ if (true) { (function () { var ReactHotAPI = __webpack_require__(217), RootInstanceProvider = __webpack_require__(59), ReactMount = __webpack_require__(61), React = __webpack_require__(115); module.makeHot = module.hot.data ? module.hot.data.makeHot : ReactHotAPI(function () { return RootInstanceProvider.getRootInstances(ReactMount); }, React); })(); } (function () {\n\n'use strict';\n\nexports.__esModule = true;\n\nvar _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; }\n\nvar _react = __webpack_require__(115);\n\nvar _react2 = _interopRequireDefault(_react);\n\nvar _classnames = __webpack_require__(253);\n\nvar _classnames2 = _interopRequireDefault(_classnames);\n\nvar TodoTextInput = (function (_Component) {\n _inherits(TodoTextInput, _Component);\n\n _createClass(TodoTextInput, null, [{\n key: 'propTypes',\n value: {\n onSave: _react.PropTypes.func.isRequired,\n text: _react.PropTypes.string,\n placeholder: _react.PropTypes.string,\n editing: _react.PropTypes.bool,\n newTodo: _react.PropTypes.bool\n },\n enumerable: true\n }]);\n\n function TodoTextInput(props, context) {\n _classCallCheck(this, TodoTextInput);\n\n _Component.call(this, props, context);\n this.state = {\n text: this.props.text || ''\n };\n }\n\n TodoTextInput.prototype.handleSubmit = function handleSubmit(e) {\n var text = e.target.value.trim();\n if (e.which === 13) {\n this.props.onSave(text);\n if (this.props.newTodo) {\n this.setState({ text: '' });\n }\n }\n };\n\n TodoTextInput.prototype.handleChange = function handleChange(e) {\n this.setState({ text: e.target.value });\n };\n\n TodoTextInput.prototype.handleBlur = function handleBlur(e) {\n if (!this.props.newTodo) {\n this.props.onSave(e.target.value);\n }\n };\n\n TodoTextInput.prototype.render = function render() {\n return _react2['default'].createElement('input', { className: _classnames2['default']({\n edit: this.props.editing,\n 'new-todo': this.props.newTodo\n }),\n type: 'text',\n placeholder: this.props.placeholder,\n autoFocus: 'true',\n value: this.state.text,\n onBlur: this.handleBlur.bind(this),\n onChange: this.handleChange.bind(this),\n onKeyDown: this.handleSubmit.bind(this) });\n };\n\n return TodoTextInput;\n})(_react.Component);\n\nexports['default'] = TodoTextInput;\nmodule.exports = exports['default'];\n\n/* REACT HOT LOADER */ }).call(this); if (true) { (function () { module.hot.dispose(function (data) { data.makeHot = module.makeHot; }); if (module.exports && module.makeHot) { var makeExportsHot = __webpack_require__(254), foundReactClasses = false; if (makeExportsHot(module, __webpack_require__(115))) { foundReactClasses = true; } var shouldAcceptModule = true && foundReactClasses; if (shouldAcceptModule) { module.hot.accept(function (err) { if (err) { console.error(\"Cannot not apply hot update to \" + \"TodoTextInput.js\" + \": \" + err.message); } }); } } })(); }\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(34)(module)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./components/TodoTextInput.js\n ** module id = 252\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./components/TodoTextInput.js?");
|
||
|
||
/***/ },
|
||
/* 253 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("var __WEBPACK_AMD_DEFINE_RESULT__;/*!\n Copyright (c) 2015 Jed Watson.\n Licensed under the MIT License (MIT), see\n http://jedwatson.github.io/classnames\n*/\n\n(function () {\n\t'use strict';\n\n\tfunction classNames () {\n\n\t\tvar classes = '';\n\n\t\tfor (var i = 0; i < arguments.length; i++) {\n\t\t\tvar arg = arguments[i];\n\t\t\tif (!arg) continue;\n\n\t\t\tvar argType = typeof arg;\n\n\t\t\tif ('string' === argType || 'number' === argType) {\n\t\t\t\tclasses += ' ' + arg;\n\n\t\t\t} else if (Array.isArray(arg)) {\n\t\t\t\tclasses += ' ' + classNames.apply(null, arg);\n\n\t\t\t} else if ('object' === argType) {\n\t\t\t\tfor (var key in arg) {\n\t\t\t\t\tif (arg.hasOwnProperty(key) && arg[key]) {\n\t\t\t\t\t\tclasses += ' ' + key;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn classes.substr(1);\n\t}\n\n\tif (typeof module !== 'undefined' && module.exports) {\n\t\tmodule.exports = classNames;\n\t} else if (true){\n\t\t// AMD. Register as an anonymous module.\n\t\t!(__WEBPACK_AMD_DEFINE_RESULT__ = function () {\n\t\t\treturn classNames;\n\t\t}.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n\t} else {\n\t\twindow.classNames = classNames;\n\t}\n\n}());\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/classnames/index.js\n ** module id = 253\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/classnames/index.js?");
|
||
|
||
/***/ },
|
||
/* 254 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("'use strict';\n\nvar isReactClassish = __webpack_require__(255),\n isReactElementish = __webpack_require__(256);\n\nfunction makeExportsHot(m, React) {\n if (isReactElementish(m.exports, React)) {\n // React elements are never valid React classes\n return false;\n }\n\n var freshExports = m.exports,\n exportsReactClass = isReactClassish(m.exports, React),\n foundReactClasses = false;\n\n if (exportsReactClass) {\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 continue;\n }\n\n if (exportsReactClass && key === 'type') {\n // React 0.12 also puts classes under `type` property for compat.\n // Skip to avoid updating twice.\n continue;\n }\n\n if (!isReactClassish(freshExports[key], React)) {\n continue;\n }\n\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 return foundReactClasses;\n}\n\nmodule.exports = makeExportsHot;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react-hot-loader/makeExportsHot.js\n ** module id = 254\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react-hot-loader/makeExportsHot.js?");
|
||
|
||
/***/ },
|
||
/* 255 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("function hasRender(Class) {\n var prototype = Class.prototype;\n if (!prototype) {\n return false;\n }\n\n return typeof prototype.render === 'function';\n}\n\nfunction descendsFromReactComponent(Class, React) {\n if (!React.Component) {\n return false;\n }\n\n var Base = Object.getPrototypeOf(Class);\n while (Base) {\n if (Base === React.Component) {\n return true;\n }\n\n Base = Object.getPrototypeOf(Base);\n }\n\n return false;\n}\n\nfunction isReactClassish(Class, React) {\n if (typeof Class !== 'function') {\n return false;\n }\n\n // React 0.13\n if (hasRender(Class) || descendsFromReactComponent(Class, React)) {\n return true;\n }\n\n // React 0.12 and earlier\n if (Class.type && hasRender(Class.type)) {\n return true;\n }\n\n return false;\n}\n\nmodule.exports = isReactClassish;\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react-hot-loader/isReactClassish.js\n ** module id = 255\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react-hot-loader/isReactClassish.js?");
|
||
|
||
/***/ },
|
||
/* 256 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("var isReactClassish = __webpack_require__(255);\n\nfunction isReactElementish(obj, React) {\n if (!obj) {\n return false;\n }\n\n return Object.prototype.toString.call(obj.props) === '[object Object]' &&\n isReactClassish(obj.type, React);\n}\n\nmodule.exports = isReactElementish;\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react-hot-loader/isReactElementish.js\n ** module id = 256\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/react-hot-loader/isReactElementish.js?");
|
||
|
||
/***/ },
|
||
/* 257 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/* WEBPACK VAR INJECTION */(function(module) {/* REACT HOT LOADER */ if (true) { (function () { var ReactHotAPI = __webpack_require__(217), RootInstanceProvider = __webpack_require__(59), ReactMount = __webpack_require__(61), React = __webpack_require__(115); module.makeHot = module.hot.data ? module.hot.data.makeHot : ReactHotAPI(function () { return RootInstanceProvider.getRootInstances(ReactMount); }, React); })(); } (function () {\n\n'use strict';\n\nexports.__esModule = true;\n\nvar _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; };\n\nvar _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();\n\nvar _TODO_FILTERS;\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; }\n\nvar _react = __webpack_require__(115);\n\nvar _react2 = _interopRequireDefault(_react);\n\nvar _TodoItem = __webpack_require__(258);\n\nvar _TodoItem2 = _interopRequireDefault(_TodoItem);\n\nvar _Footer = __webpack_require__(259);\n\nvar _Footer2 = _interopRequireDefault(_Footer);\n\nvar _constantsTodoFilters = __webpack_require__(260);\n\nvar TODO_FILTERS = (_TODO_FILTERS = {}, _TODO_FILTERS[_constantsTodoFilters.SHOW_ALL] = function () {\n return true;\n}, _TODO_FILTERS[_constantsTodoFilters.SHOW_UNMARKED] = function (todo) {\n return !todo.marked;\n}, _TODO_FILTERS[_constantsTodoFilters.SHOW_MARKED] = function (todo) {\n return todo.marked;\n}, _TODO_FILTERS);\n\nvar MainSection = (function (_Component) {\n _inherits(MainSection, _Component);\n\n _createClass(MainSection, null, [{\n key: 'propTypes',\n value: {\n todos: _react.PropTypes.array.isRequired,\n actions: _react.PropTypes.object.isRequired\n },\n enumerable: true\n }]);\n\n function MainSection(props, context) {\n _classCallCheck(this, MainSection);\n\n _Component.call(this, props, context);\n this.state = { filter: _constantsTodoFilters.SHOW_ALL };\n }\n\n MainSection.prototype.handleClearMarked = function handleClearMarked() {\n var atLeastOneMarked = this.props.todos.some(function (todo) {\n return todo.marked;\n });\n if (atLeastOneMarked) {\n this.props.actions.clearMarked();\n }\n };\n\n MainSection.prototype.handleShow = function handleShow(filter) {\n this.setState({ filter: filter });\n };\n\n MainSection.prototype.render = function render() {\n var _props = this.props;\n var todos = _props.todos;\n var actions = _props.actions;\n var filter = this.state.filter;\n\n var filteredTodos = todos.filter(TODO_FILTERS[filter]);\n var markedCount = todos.reduce(function (count, todo) {\n return todo.marked ? count + 1 : count;\n }, 0);\n\n return _react2['default'].createElement(\n 'section',\n { className: 'main' },\n this.renderToggleAll(markedCount),\n _react2['default'].createElement(\n 'ul',\n { className: 'todo-list' },\n filteredTodos.map(function (todo) {\n return _react2['default'].createElement(_TodoItem2['default'], _extends({ key: todo.id, todo: todo }, actions));\n })\n ),\n this.renderFooter(markedCount)\n );\n };\n\n MainSection.prototype.renderToggleAll = function renderToggleAll(markedCount) {\n var _props2 = this.props;\n var todos = _props2.todos;\n var actions = _props2.actions;\n\n if (todos.length > 0) {\n return _react2['default'].createElement('input', { className: 'toggle-all',\n type: 'checkbox',\n checked: markedCount === todos.length,\n onChange: actions.markAll });\n }\n };\n\n MainSection.prototype.renderFooter = function renderFooter(markedCount) {\n var todos = this.props.todos;\n var filter = this.state.filter;\n\n var unmarkedCount = todos.length - markedCount;\n\n if (todos.length) {\n return _react2['default'].createElement(_Footer2['default'], { markedCount: markedCount,\n unmarkedCount: unmarkedCount,\n filter: filter,\n onClearMarked: this.handleClearMarked.bind(this),\n onShow: this.handleShow.bind(this) });\n }\n };\n\n return MainSection;\n})(_react.Component);\n\nexports['default'] = MainSection;\nmodule.exports = exports['default'];\n\n/* REACT HOT LOADER */ }).call(this); if (true) { (function () { module.hot.dispose(function (data) { data.makeHot = module.makeHot; }); if (module.exports && module.makeHot) { var makeExportsHot = __webpack_require__(254), foundReactClasses = false; if (makeExportsHot(module, __webpack_require__(115))) { foundReactClasses = true; } var shouldAcceptModule = true && foundReactClasses; if (shouldAcceptModule) { module.hot.accept(function (err) { if (err) { console.error(\"Cannot not apply hot update to \" + \"MainSection.js\" + \": \" + err.message); } }); } } })(); }\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(34)(module)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./components/MainSection.js\n ** module id = 257\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./components/MainSection.js?");
|
||
|
||
/***/ },
|
||
/* 258 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/* WEBPACK VAR INJECTION */(function(module) {/* REACT HOT LOADER */ if (true) { (function () { var ReactHotAPI = __webpack_require__(217), RootInstanceProvider = __webpack_require__(59), ReactMount = __webpack_require__(61), React = __webpack_require__(115); module.makeHot = module.hot.data ? module.hot.data.makeHot : ReactHotAPI(function () { return RootInstanceProvider.getRootInstances(ReactMount); }, React); })(); } (function () {\n\n'use strict';\n\nexports.__esModule = true;\n\nvar _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; }\n\nvar _react = __webpack_require__(115);\n\nvar _react2 = _interopRequireDefault(_react);\n\nvar _classnames = __webpack_require__(253);\n\nvar _classnames2 = _interopRequireDefault(_classnames);\n\nvar _TodoTextInput = __webpack_require__(252);\n\nvar _TodoTextInput2 = _interopRequireDefault(_TodoTextInput);\n\nvar TodoItem = (function (_Component) {\n _inherits(TodoItem, _Component);\n\n _createClass(TodoItem, null, [{\n key: 'propTypes',\n value: {\n todo: _react.PropTypes.object.isRequired,\n editTodo: _react.PropTypes.func.isRequired,\n deleteTodo: _react.PropTypes.func.isRequired,\n markTodo: _react.PropTypes.func.isRequired\n },\n enumerable: true\n }]);\n\n function TodoItem(props, context) {\n _classCallCheck(this, TodoItem);\n\n _Component.call(this, props, context);\n this.state = {\n editing: false\n };\n }\n\n TodoItem.prototype.handleDoubleClick = function handleDoubleClick() {\n this.setState({ editing: true });\n };\n\n TodoItem.prototype.handleSave = function handleSave(id, text) {\n if (text.length === 0) {\n this.props.deleteTodo(id);\n } else {\n this.props.editTodo(id, text);\n }\n this.setState({ editing: false });\n };\n\n TodoItem.prototype.render = function render() {\n var _this = this;\n\n var _props = this.props;\n var todo = _props.todo;\n var markTodo = _props.markTodo;\n var deleteTodo = _props.deleteTodo;\n\n var element = undefined;\n if (this.state.editing) {\n element = _react2['default'].createElement(_TodoTextInput2['default'], { text: todo.text,\n editing: this.state.editing,\n onSave: function (text) {\n return _this.handleSave(todo.id, text);\n } });\n } else {\n element = _react2['default'].createElement(\n 'div',\n { className: 'view' },\n _react2['default'].createElement('input', { className: 'toggle',\n type: 'checkbox',\n checked: todo.marked,\n onChange: function () {\n return markTodo(todo.id);\n } }),\n _react2['default'].createElement(\n 'label',\n { onDoubleClick: this.handleDoubleClick.bind(this) },\n todo.text\n ),\n _react2['default'].createElement('button', { className: 'destroy',\n onClick: function () {\n return deleteTodo(todo.id);\n } })\n );\n }\n\n return _react2['default'].createElement(\n 'li',\n { className: _classnames2['default']({\n completed: todo.marked,\n editing: this.state.editing\n }) },\n element\n );\n };\n\n return TodoItem;\n})(_react.Component);\n\nexports['default'] = TodoItem;\nmodule.exports = exports['default'];\n\n/* REACT HOT LOADER */ }).call(this); if (true) { (function () { module.hot.dispose(function (data) { data.makeHot = module.makeHot; }); if (module.exports && module.makeHot) { var makeExportsHot = __webpack_require__(254), foundReactClasses = false; if (makeExportsHot(module, __webpack_require__(115))) { foundReactClasses = true; } var shouldAcceptModule = true && foundReactClasses; if (shouldAcceptModule) { module.hot.accept(function (err) { if (err) { console.error(\"Cannot not apply hot update to \" + \"TodoItem.js\" + \": \" + err.message); } }); } } })(); }\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(34)(module)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./components/TodoItem.js\n ** module id = 258\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./components/TodoItem.js?");
|
||
|
||
/***/ },
|
||
/* 259 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/* WEBPACK VAR INJECTION */(function(module) {/* REACT HOT LOADER */ if (true) { (function () { var ReactHotAPI = __webpack_require__(217), RootInstanceProvider = __webpack_require__(59), ReactMount = __webpack_require__(61), React = __webpack_require__(115); module.makeHot = module.hot.data ? module.hot.data.makeHot : ReactHotAPI(function () { return RootInstanceProvider.getRootInstances(ReactMount); }, React); })(); } (function () {\n\n'use strict';\n\nexports.__esModule = true;\n\nvar _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();\n\nvar _FILTER_TITLES;\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; }\n\nvar _react = __webpack_require__(115);\n\nvar _react2 = _interopRequireDefault(_react);\n\nvar _classnames = __webpack_require__(253);\n\nvar _classnames2 = _interopRequireDefault(_classnames);\n\nvar _constantsTodoFilters = __webpack_require__(260);\n\nvar FILTER_TITLES = (_FILTER_TITLES = {}, _FILTER_TITLES[_constantsTodoFilters.SHOW_ALL] = 'All', _FILTER_TITLES[_constantsTodoFilters.SHOW_UNMARKED] = 'Active', _FILTER_TITLES[_constantsTodoFilters.SHOW_MARKED] = 'Completed', _FILTER_TITLES);\n\nvar Footer = (function (_Component) {\n _inherits(Footer, _Component);\n\n function Footer() {\n _classCallCheck(this, Footer);\n\n _Component.apply(this, arguments);\n }\n\n Footer.prototype.render = function render() {\n var _this = this;\n\n return _react2['default'].createElement(\n 'footer',\n { className: 'footer' },\n this.renderTodoCount(),\n _react2['default'].createElement(\n 'ul',\n { className: 'filters' },\n [_constantsTodoFilters.SHOW_ALL, _constantsTodoFilters.SHOW_UNMARKED, _constantsTodoFilters.SHOW_MARKED].map(function (filter) {\n return _react2['default'].createElement(\n 'li',\n { key: filter },\n _this.renderFilterLink(filter)\n );\n })\n ),\n this.renderClearButton()\n );\n };\n\n Footer.prototype.renderTodoCount = function renderTodoCount() {\n var unmarkedCount = this.props.unmarkedCount;\n\n var itemWord = unmarkedCount === 1 ? 'item' : 'items';\n\n return _react2['default'].createElement(\n 'span',\n { className: 'todo-count' },\n _react2['default'].createElement(\n 'strong',\n null,\n unmarkedCount || 'No'\n ),\n ' ',\n itemWord,\n ' left'\n );\n };\n\n Footer.prototype.renderFilterLink = function renderFilterLink(filter) {\n var title = FILTER_TITLES[filter];\n var _props = this.props;\n var selectedFilter = _props.filter;\n var onShow = _props.onShow;\n\n return _react2['default'].createElement(\n 'a',\n { className: _classnames2['default']({ selected: filter === selectedFilter }),\n style: { cursor: 'hand' },\n onClick: function () {\n return onShow(filter);\n } },\n title\n );\n };\n\n Footer.prototype.renderClearButton = function renderClearButton() {\n var _props2 = this.props;\n var markedCount = _props2.markedCount;\n var onClearMarked = _props2.onClearMarked;\n\n if (markedCount > 0) {\n return _react2['default'].createElement(\n 'button',\n { className: 'clear-completed',\n onClick: onClearMarked },\n 'Clear completed'\n );\n }\n };\n\n _createClass(Footer, null, [{\n key: 'propTypes',\n value: {\n markedCount: _react.PropTypes.number.isRequired,\n unmarkedCount: _react.PropTypes.number.isRequired,\n filter: _react.PropTypes.string.isRequired,\n onClearMarked: _react.PropTypes.func.isRequired,\n onShow: _react.PropTypes.func.isRequired\n },\n enumerable: true\n }]);\n\n return Footer;\n})(_react.Component);\n\nexports['default'] = Footer;\nmodule.exports = exports['default'];\n\n/* REACT HOT LOADER */ }).call(this); if (true) { (function () { module.hot.dispose(function (data) { data.makeHot = module.makeHot; }); if (module.exports && module.makeHot) { var makeExportsHot = __webpack_require__(254), foundReactClasses = false; if (makeExportsHot(module, __webpack_require__(115))) { foundReactClasses = true; } var shouldAcceptModule = true && foundReactClasses; if (shouldAcceptModule) { module.hot.accept(function (err) { if (err) { console.error(\"Cannot not apply hot update to \" + \"Footer.js\" + \": \" + err.message); } }); } } })(); }\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(34)(module)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./components/Footer.js\n ** module id = 259\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./components/Footer.js?");
|
||
|
||
/***/ },
|
||
/* 260 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/* WEBPACK VAR INJECTION */(function(module) {/* REACT HOT LOADER */ if (true) { (function () { var ReactHotAPI = __webpack_require__(217), RootInstanceProvider = __webpack_require__(59), ReactMount = __webpack_require__(61), React = __webpack_require__(115); module.makeHot = module.hot.data ? module.hot.data.makeHot : ReactHotAPI(function () { return RootInstanceProvider.getRootInstances(ReactMount); }, React); })(); } (function () {\n\n'use strict';\n\nexports.__esModule = true;\nvar SHOW_ALL = 'show_all';\nexports.SHOW_ALL = SHOW_ALL;\nvar SHOW_MARKED = 'show_marked';\nexports.SHOW_MARKED = SHOW_MARKED;\nvar SHOW_UNMARKED = 'show_unmarked';\nexports.SHOW_UNMARKED = SHOW_UNMARKED;\n\n/* REACT HOT LOADER */ }).call(this); if (true) { (function () { module.hot.dispose(function (data) { data.makeHot = module.makeHot; }); if (module.exports && module.makeHot) { var makeExportsHot = __webpack_require__(254), foundReactClasses = false; if (makeExportsHot(module, __webpack_require__(115))) { foundReactClasses = true; } var shouldAcceptModule = true && foundReactClasses; if (shouldAcceptModule) { module.hot.accept(function (err) { if (err) { console.error(\"Cannot not apply hot update to \" + \"TodoFilters.js\" + \": \" + err.message); } }); } } })(); }\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(34)(module)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./constants/TodoFilters.js\n ** module id = 260\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./constants/TodoFilters.js?");
|
||
|
||
/***/ },
|
||
/* 261 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/* WEBPACK VAR INJECTION */(function(module) {/* REACT HOT LOADER */ if (true) { (function () { var ReactHotAPI = __webpack_require__(217), RootInstanceProvider = __webpack_require__(59), ReactMount = __webpack_require__(61), React = __webpack_require__(115); module.makeHot = module.hot.data ? module.hot.data.makeHot : ReactHotAPI(function () { return RootInstanceProvider.getRootInstances(ReactMount); }, React); })(); } (function () {\n\n'use strict';\n\nexports.__esModule = true;\nexports.addTodo = addTodo;\nexports.deleteTodo = deleteTodo;\nexports.editTodo = editTodo;\nexports.markTodo = markTodo;\nexports.markAll = markAll;\nexports.clearMarked = clearMarked;\n\nfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }\n\nvar _constantsActionTypes = __webpack_require__(262);\n\nvar types = _interopRequireWildcard(_constantsActionTypes);\n\nfunction addTodo(text) {\n return {\n type: types.ADD_TODO,\n text: text\n };\n}\n\nfunction deleteTodo(id) {\n return {\n type: types.DELETE_TODO,\n id: id\n };\n}\n\nfunction editTodo(id, text) {\n return {\n type: types.EDIT_TODO,\n id: id,\n text: text\n };\n}\n\nfunction markTodo(id) {\n return {\n type: types.MARK_TODO,\n id: id\n };\n}\n\nfunction markAll() {\n return {\n type: types.MARK_ALL\n };\n}\n\nfunction clearMarked() {\n return {\n type: types.CLEAR_MARKED\n };\n}\n\n/* REACT HOT LOADER */ }).call(this); if (true) { (function () { module.hot.dispose(function (data) { data.makeHot = module.makeHot; }); if (module.exports && module.makeHot) { var makeExportsHot = __webpack_require__(254), foundReactClasses = false; if (makeExportsHot(module, __webpack_require__(115))) { foundReactClasses = true; } var shouldAcceptModule = true && foundReactClasses; if (shouldAcceptModule) { module.hot.accept(function (err) { if (err) { console.error(\"Cannot not apply hot update to \" + \"TodoActions.js\" + \": \" + err.message); } }); } } })(); }\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(34)(module)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./actions/TodoActions.js\n ** module id = 261\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./actions/TodoActions.js?");
|
||
|
||
/***/ },
|
||
/* 262 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/* WEBPACK VAR INJECTION */(function(module) {/* REACT HOT LOADER */ if (true) { (function () { var ReactHotAPI = __webpack_require__(217), RootInstanceProvider = __webpack_require__(59), ReactMount = __webpack_require__(61), React = __webpack_require__(115); module.makeHot = module.hot.data ? module.hot.data.makeHot : ReactHotAPI(function () { return RootInstanceProvider.getRootInstances(ReactMount); }, React); })(); } (function () {\n\n'use strict';\n\nexports.__esModule = true;\nvar ADD_TODO = 'ADD_TODO';\nexports.ADD_TODO = ADD_TODO;\nvar DELETE_TODO = 'DELETE_TODO';\nexports.DELETE_TODO = DELETE_TODO;\nvar EDIT_TODO = 'EDIT_TODO';\nexports.EDIT_TODO = EDIT_TODO;\nvar MARK_TODO = 'MARK_TODO';\nexports.MARK_TODO = MARK_TODO;\nvar MARK_ALL = 'MARK_ALL';\nexports.MARK_ALL = MARK_ALL;\nvar CLEAR_MARKED = 'CLEAR_MARKED';\nexports.CLEAR_MARKED = CLEAR_MARKED;\n\n/* REACT HOT LOADER */ }).call(this); if (true) { (function () { module.hot.dispose(function (data) { data.makeHot = module.makeHot; }); if (module.exports && module.makeHot) { var makeExportsHot = __webpack_require__(254), foundReactClasses = false; if (makeExportsHot(module, __webpack_require__(115))) { foundReactClasses = true; } var shouldAcceptModule = true && foundReactClasses; if (shouldAcceptModule) { module.hot.accept(function (err) { if (err) { console.error(\"Cannot not apply hot update to \" + \"ActionTypes.js\" + \": \" + err.message); } }); } } })(); }\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(34)(module)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./constants/ActionTypes.js\n ** module id = 262\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./constants/ActionTypes.js?");
|
||
|
||
/***/ },
|
||
/* 263 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("'use strict';\n\nexports.__esModule = true;\n\nfunction _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }\n\nvar _devTools = __webpack_require__(264);\n\nexports.devTools = _interopRequire(_devTools);\n\nvar _persistState = __webpack_require__(265);\n\nexports.persistState = _interopRequire(_persistState);\n\n/*****************\n ** WEBPACK FOOTER\n ** /Users/sergeylapin/lapanoid-redux-devtools/src/index.js\n ** module id = 263\n ** module chunks = 0\n **/\n//# sourceURL=webpack:////Users/sergeylapin/lapanoid-redux-devtools/src/index.js?");
|
||
|
||
/***/ },
|
||
/* 264 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("'use strict';\n\nexports.__esModule = true;\n\nvar _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; };\n\nexports['default'] = devTools;\nvar ActionTypes = {\n PERFORM_ACTION: 'PERFORM_ACTION',\n RESET: 'RESET',\n ROLLBACK: 'ROLLBACK',\n COMMIT: 'COMMIT',\n SWEEP: 'SWEEP',\n TOGGLE_ACTION: 'TOGGLE_ACTION',\n JUMP_TO_STATE: 'JUMP_TO_STATE',\n SET_MONITOR_STATE: 'SET_MONITOR_STATE'\n};\n\nvar INIT_ACTION = {\n type: '@@INIT'\n};\n\nfunction toggle(obj, key) {\n var clone = _extends({}, obj);\n if (clone[key]) {\n delete clone[key];\n } else {\n clone[key] = true;\n }\n return clone;\n}\n\n/**\n * Computes the next entry in the log by applying an action.\n */\nfunction computeNextEntry(reducer, action, state, error) {\n if (error) {\n return {\n state: state,\n error: 'Interrupted by an error up the chain'\n };\n }\n\n var nextState = state;\n var nextError = undefined;\n try {\n nextState = reducer(state, action);\n } catch (err) {\n nextError = err.toString();\n }\n\n return {\n state: nextState,\n error: nextError\n };\n}\n\n/**\n * Runs the reducer on all actions to get a fresh computation log.\n * It's probably a good idea to do this only if the code has changed,\n * but until we have some tests we'll just do it every time an action fires.\n */\nfunction recomputeStates(reducer, committedState, stagedActions, skippedActions) {\n var computedStates = [];\n\n for (var i = 0; i < stagedActions.length; i++) {\n var action = stagedActions[i];\n\n var previousEntry = computedStates[i - 1];\n var previousState = previousEntry ? previousEntry.state : committedState;\n var previousError = previousEntry ? previousEntry.error : undefined;\n\n var shouldSkip = Boolean(skippedActions[i]);\n var entry = shouldSkip ? previousEntry : computeNextEntry(reducer, action, previousState, previousError);\n\n computedStates.push(entry);\n }\n\n return computedStates;\n}\n\n/**\n * Lifts the app state reducer into a DevTools state reducer.\n */\nfunction liftReducer(reducer, initialState) {\n var initialLiftedState = {\n committedState: initialState,\n stagedActions: [INIT_ACTION],\n skippedActions: {},\n currentStateIndex: 0,\n monitorState: {\n isVisible: true\n }\n };\n\n /**\n * Manages how the DevTools actions modify the DevTools state.\n */\n return function liftedReducer(liftedState, liftedAction) {\n if (liftedState === undefined) liftedState = initialLiftedState;\n var committedState = liftedState.committedState;\n var stagedActions = liftedState.stagedActions;\n var skippedActions = liftedState.skippedActions;\n var computedStates = liftedState.computedStates;\n var currentStateIndex = liftedState.currentStateIndex;\n var monitorState = liftedState.monitorState;\n\n switch (liftedAction.type) {\n case ActionTypes.RESET:\n committedState = initialState;\n stagedActions = [INIT_ACTION];\n skippedActions = {};\n currentStateIndex = 0;\n break;\n case ActionTypes.COMMIT:\n committedState = computedStates[currentStateIndex].state;\n stagedActions = [INIT_ACTION];\n skippedActions = {};\n currentStateIndex = 0;\n break;\n case ActionTypes.ROLLBACK:\n stagedActions = [INIT_ACTION];\n skippedActions = {};\n currentStateIndex = 0;\n break;\n case ActionTypes.TOGGLE_ACTION:\n skippedActions = toggle(skippedActions, liftedAction.index);\n break;\n case ActionTypes.JUMP_TO_STATE:\n currentStateIndex = liftedAction.index;\n break;\n case ActionTypes.SWEEP:\n stagedActions = stagedActions.filter(function (_, i) {\n return !skippedActions[i];\n });\n skippedActions = {};\n currentStateIndex = Math.max(currentStateIndex, stagedActions.length - 1);\n break;\n case ActionTypes.PERFORM_ACTION:\n if (currentStateIndex === stagedActions.length - 1) {\n currentStateIndex++;\n }\n stagedActions = [].concat(stagedActions, [liftedAction.action]);\n break;\n case ActionTypes.SET_MONITOR_STATE:\n monitorState = liftedAction.monitorState;\n break;\n default:\n break;\n }\n\n computedStates = recomputeStates(reducer, committedState, stagedActions, skippedActions);\n\n return {\n committedState: committedState,\n stagedActions: stagedActions,\n skippedActions: skippedActions,\n computedStates: computedStates,\n currentStateIndex: currentStateIndex,\n monitorState: monitorState\n };\n };\n}\n\n/**\n * Lifts an app action to a DevTools action.\n */\nfunction liftAction(action) {\n var liftedAction = { type: ActionTypes.PERFORM_ACTION, action: action };\n return liftedAction;\n}\n\n/**\n * Unlifts the DevTools state to the app state.\n */\nfunction unliftState(liftedState) {\n var computedStates = liftedState.computedStates;\n var currentStateIndex = liftedState.currentStateIndex;\n var state = computedStates[currentStateIndex].state;\n\n return state;\n}\n\n/**\n * Unlifts the DevTools store to act like the app's store.\n */\nfunction unliftStore(liftedStore, reducer) {\n return _extends({}, liftedStore, {\n devToolsStore: liftedStore,\n dispatch: function dispatch(action) {\n liftedStore.dispatch(liftAction(action));\n return action;\n },\n getState: function getState() {\n return unliftState(liftedStore.getState());\n },\n getReducer: function getReducer() {\n return reducer;\n },\n replaceReducer: function replaceReducer(nextReducer) {\n liftedStore.replaceReducer(liftReducer(nextReducer));\n }\n });\n}\n\n/**\n * Action creators to change the DevTools state.\n */\nvar ActionCreators = {\n reset: function reset() {\n return { type: ActionTypes.RESET };\n },\n rollback: function rollback() {\n return { type: ActionTypes.ROLLBACK };\n },\n commit: function commit() {\n return { type: ActionTypes.COMMIT };\n },\n sweep: function sweep() {\n return { type: ActionTypes.SWEEP };\n },\n toggleAction: function toggleAction(index) {\n return { type: ActionTypes.TOGGLE_ACTION, index: index };\n },\n jumpToState: function jumpToState(index) {\n return { type: ActionTypes.JUMP_TO_STATE, index: index };\n },\n setMonitorState: function setMonitorState(monitorState) {\n return { type: ActionTypes.SET_MONITOR_STATE, monitorState: monitorState };\n }\n};\n\nexports.ActionCreators = ActionCreators;\n/**\n * Redux DevTools middleware.\n */\n\nfunction devTools() {\n return function (next) {\n return function (reducer, initialState) {\n var liftedReducer = liftReducer(reducer, initialState);\n var liftedStore = next(liftedReducer);\n var store = unliftStore(liftedStore, reducer);\n return store;\n };\n };\n}\n\n/*****************\n ** WEBPACK FOOTER\n ** /Users/sergeylapin/lapanoid-redux-devtools/src/devTools.js\n ** module id = 264\n ** module chunks = 0\n **/\n//# sourceURL=webpack:////Users/sergeylapin/lapanoid-redux-devtools/src/devTools.js?");
|
||
|
||
/***/ },
|
||
/* 265 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("'use strict';\n\nexports.__esModule = true;\n\nvar _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; };\n\nexports['default'] = persistState;\n\nfunction persistState(sessionId) {\n if (!sessionId) {\n return function (next) {\n return function () {\n return next.apply(undefined, arguments);\n };\n };\n }\n\n return function (next) {\n return function (reducer, initialState) {\n var key = 'redux-dev-session-' + sessionId;\n\n var finalInitialState = undefined;\n try {\n finalInitialState = JSON.parse(localStorage.getItem(key)) || initialState;\n next(reducer, initialState);\n } catch (e) {\n console.warn('Could not read debug session from localStorage:', e);\n try {\n localStorage.removeItem(key);\n } finally {\n finalInitialState = undefined;\n }\n }\n\n var store = next(reducer, finalInitialState);\n\n return _extends({}, store, {\n dispatch: function dispatch(action) {\n store.dispatch(action);\n\n try {\n localStorage.setItem(key, JSON.stringify(store.getState()));\n } catch (e) {\n console.warn('Could not write debug session from localStorage:', e);\n }\n\n return action;\n }\n });\n };\n };\n}\n\nmodule.exports = exports['default'];\n\n/*****************\n ** WEBPACK FOOTER\n ** /Users/sergeylapin/lapanoid-redux-devtools/src/persistState.js\n ** module id = 265\n ** module chunks = 0\n **/\n//# sourceURL=webpack:////Users/sergeylapin/lapanoid-redux-devtools/src/persistState.js?");
|
||
|
||
/***/ },
|
||
/* 266 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("'use strict';\n\nexports.__esModule = true;\n\nfunction _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nvar _react = __webpack_require__(115);\n\nvar _react2 = _interopRequireDefault(_react);\n\nvar _createDevTools = __webpack_require__(267);\n\nvar _createDevTools2 = _interopRequireDefault(_createDevTools);\n\nvar DevTools = _createDevTools2['default'](_react2['default']);\nexports.DevTools = DevTools;\n\nvar _LogMonitor = __webpack_require__(291);\n\nexports.LogMonitor = _interopRequire(_LogMonitor);\n\nvar _DebugPanel = __webpack_require__(293);\n\nexports.DebugPanel = _interopRequire(_DebugPanel);\n\n/*****************\n ** WEBPACK FOOTER\n ** /Users/sergeylapin/lapanoid-redux-devtools/src/react/index.js\n ** module id = 266\n ** module chunks = 0\n **/\n//# sourceURL=webpack:////Users/sergeylapin/lapanoid-redux-devtools/src/react/index.js?");
|
||
|
||
/***/ },
|
||
/* 267 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("'use strict';\n\nexports.__esModule = true;\n\nvar _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; };\n\nvar _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();\n\nexports['default'] = createDevTools;\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nfunction _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; }\n\nvar _reactReduxLibComponentsCreateAll = __webpack_require__(268);\n\nvar _reactReduxLibComponentsCreateAll2 = _interopRequireDefault(_reactReduxLibComponentsCreateAll);\n\nvar _redux = __webpack_require__(279);\n\nvar _devTools = __webpack_require__(264);\n\nfunction createDevTools(React) {\n var PropTypes = React.PropTypes;\n var Component = React.Component;\n\n var _createAll = _reactReduxLibComponentsCreateAll2['default'](React);\n\n var Provider = _createAll.Provider;\n var Connector = _createAll.Connector;\n\n return (function (_Component) {\n _inherits(DevTools, _Component);\n\n _createClass(DevTools, null, [{\n key: 'propTypes',\n value: {\n monitor: PropTypes.func.isRequired,\n store: PropTypes.shape({\n devToolsStore: PropTypes.shape({\n dispatch: PropTypes.func.isRequired\n }).isRequired\n }).isRequired\n },\n enumerable: true\n }]);\n\n function DevTools(props, context) {\n var _this = this;\n\n _classCallCheck(this, DevTools);\n\n if (props.store && !props.store.devToolsStore) {\n console.error('Could not find the devTools store inside your store. ' + 'Have you applied devTools() higher-order store?');\n }\n _Component.call(this, props, context);\n\n this.renderRoot = function () {\n return React.createElement(\n Connector,\n null,\n _this.renderMonitor\n );\n };\n\n this.renderMonitor = function (_ref) {\n var dispatch = _ref.dispatch;\n\n var state = _objectWithoutProperties(_ref, ['dispatch']);\n\n var _props = _this.props;\n var Monitor = _props.monitor;\n\n var rest = _objectWithoutProperties(_props, ['monitor']);\n\n return React.createElement(Monitor, _extends({}, state, _redux.bindActionCreators(_devTools.ActionCreators, dispatch), rest));\n };\n }\n\n DevTools.prototype.render = function render() {\n var devToolsStore = this.props.store.devToolsStore;\n\n return React.createElement(\n Provider,\n { store: devToolsStore },\n this.renderRoot\n );\n };\n\n return DevTools;\n })(Component);\n}\n\nmodule.exports = exports['default'];\n\n/*****************\n ** WEBPACK FOOTER\n ** /Users/sergeylapin/lapanoid-redux-devtools/src/createDevTools.js\n ** module id = 267\n ** module chunks = 0\n **/\n//# sourceURL=webpack:////Users/sergeylapin/lapanoid-redux-devtools/src/createDevTools.js?");
|
||
|
||
/***/ },
|
||
/* 268 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("'use strict';\n\nexports.__esModule = true;\nexports['default'] = createAll;\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nvar _createProvider = __webpack_require__(269);\n\nvar _createProvider2 = _interopRequireDefault(_createProvider);\n\nvar _createProvideDecorator = __webpack_require__(271);\n\nvar _createProvideDecorator2 = _interopRequireDefault(_createProvideDecorator);\n\nvar _createConnector = __webpack_require__(273);\n\nvar _createConnector2 = _interopRequireDefault(_createConnector);\n\nvar _createConnectDecorator = __webpack_require__(277);\n\nvar _createConnectDecorator2 = _interopRequireDefault(_createConnectDecorator);\n\nfunction createAll(React) {\n // Wrapper components\n var Provider = _createProvider2['default'](React);\n var Connector = _createConnector2['default'](React);\n\n // Higher-order components (decorators)\n var provide = _createProvideDecorator2['default'](React, Provider);\n var connect = _createConnectDecorator2['default'](React, Connector);\n\n return { Provider: Provider, Connector: Connector, provide: provide, connect: connect };\n}\n\nmodule.exports = exports['default'];\n\n/*****************\n ** WEBPACK FOOTER\n ** /Users/sergeylapin/~/react-redux/lib/components/createAll.js\n ** module id = 268\n ** module chunks = 0\n **/\n//# sourceURL=webpack:////Users/sergeylapin/~/react-redux/lib/components/createAll.js?");
|
||
|
||
/***/ },
|
||
/* 269 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("'use strict';\n\nexports.__esModule = true;\n\nvar _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();\n\nexports['default'] = createProvider;\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; }\n\nvar _utilsCreateStoreShape = __webpack_require__(270);\n\nvar _utilsCreateStoreShape2 = _interopRequireDefault(_utilsCreateStoreShape);\n\nfunction createProvider(React) {\n var Component = React.Component;\n var PropTypes = React.PropTypes;\n\n var storeShape = _utilsCreateStoreShape2['default'](PropTypes);\n\n return (function (_Component) {\n function Provider(props, context) {\n _classCallCheck(this, Provider);\n\n _Component.call(this, props, context);\n this.state = { store: props.store };\n }\n\n _inherits(Provider, _Component);\n\n Provider.prototype.getChildContext = function getChildContext() {\n return { store: this.state.store };\n };\n\n Provider.prototype.componentWillReceiveProps = function componentWillReceiveProps(nextProps) {\n var store = this.state.store;\n var nextStore = nextProps.store;\n\n if (store !== nextStore) {\n var nextReducer = nextStore.getReducer();\n store.replaceReducer(nextReducer);\n }\n };\n\n Provider.prototype.render = function render() {\n var children = this.props.children;\n\n return children();\n };\n\n _createClass(Provider, null, [{\n key: 'childContextTypes',\n value: {\n store: storeShape.isRequired\n },\n enumerable: true\n }, {\n key: 'propTypes',\n value: {\n children: PropTypes.func.isRequired\n },\n enumerable: true\n }]);\n\n return Provider;\n })(Component);\n}\n\nmodule.exports = exports['default'];\n\n/*****************\n ** WEBPACK FOOTER\n ** /Users/sergeylapin/~/react-redux/lib/components/createProvider.js\n ** module id = 269\n ** module chunks = 0\n **/\n//# sourceURL=webpack:////Users/sergeylapin/~/react-redux/lib/components/createProvider.js?");
|
||
|
||
/***/ },
|
||
/* 270 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("\"use strict\";\n\nexports.__esModule = true;\nexports[\"default\"] = createStoreShape;\n\nfunction createStoreShape(PropTypes) {\n return PropTypes.shape({\n subscribe: PropTypes.func.isRequired,\n dispatch: PropTypes.func.isRequired,\n getState: PropTypes.func.isRequired\n });\n}\n\nmodule.exports = exports[\"default\"];\n\n/*****************\n ** WEBPACK FOOTER\n ** /Users/sergeylapin/~/react-redux/lib/utils/createStoreShape.js\n ** module id = 270\n ** module chunks = 0\n **/\n//# sourceURL=webpack:////Users/sergeylapin/~/react-redux/lib/utils/createStoreShape.js?");
|
||
|
||
/***/ },
|
||
/* 271 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("'use strict';\n\nexports.__esModule = true;\n\nvar _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();\n\nexports['default'] = createProvideDecorator;\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; }\n\nvar _utilsGetDisplayName = __webpack_require__(272);\n\nvar _utilsGetDisplayName2 = _interopRequireDefault(_utilsGetDisplayName);\n\nfunction createProvideDecorator(React, Provider) {\n var Component = React.Component;\n\n return function provide(store) {\n return function (DecoratedComponent) {\n return (function (_Component) {\n function ProviderDecorator() {\n _classCallCheck(this, ProviderDecorator);\n\n _Component.apply(this, arguments);\n }\n\n _inherits(ProviderDecorator, _Component);\n\n ProviderDecorator.prototype.render = function render() {\n var _this = this;\n\n return React.createElement(\n Provider,\n { store: store },\n function () {\n return React.createElement(DecoratedComponent, _this.props);\n }\n );\n };\n\n _createClass(ProviderDecorator, null, [{\n key: 'displayName',\n value: 'Provider(' + _utilsGetDisplayName2['default'](DecoratedComponent) + ')',\n enumerable: true\n }, {\n key: 'DecoratedComponent',\n value: DecoratedComponent,\n enumerable: true\n }]);\n\n return ProviderDecorator;\n })(Component);\n };\n };\n}\n\nmodule.exports = exports['default'];\n\n/*****************\n ** WEBPACK FOOTER\n ** /Users/sergeylapin/~/react-redux/lib/components/createProvideDecorator.js\n ** module id = 271\n ** module chunks = 0\n **/\n//# sourceURL=webpack:////Users/sergeylapin/~/react-redux/lib/components/createProvideDecorator.js?");
|
||
|
||
/***/ },
|
||
/* 272 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("'use strict';\n\nexports.__esModule = true;\nexports['default'] = getDisplayName;\n\nfunction getDisplayName(Component) {\n return Component.displayName || Component.name || 'Component';\n}\n\nmodule.exports = exports['default'];\n\n/*****************\n ** WEBPACK FOOTER\n ** /Users/sergeylapin/~/react-redux/lib/utils/getDisplayName.js\n ** module id = 272\n ** module chunks = 0\n **/\n//# sourceURL=webpack:////Users/sergeylapin/~/react-redux/lib/utils/getDisplayName.js?");
|
||
|
||
/***/ },
|
||
/* 273 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("'use strict';\n\nexports.__esModule = true;\n\nvar _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; };\n\nvar _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();\n\nexports['default'] = createConnector;\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; }\n\nvar _utilsCreateStoreShape = __webpack_require__(270);\n\nvar _utilsCreateStoreShape2 = _interopRequireDefault(_utilsCreateStoreShape);\n\nvar _utilsShallowEqual = __webpack_require__(274);\n\nvar _utilsShallowEqual2 = _interopRequireDefault(_utilsShallowEqual);\n\nvar _utilsIsPlainObject = __webpack_require__(275);\n\nvar _utilsIsPlainObject2 = _interopRequireDefault(_utilsIsPlainObject);\n\nvar _invariant = __webpack_require__(276);\n\nvar _invariant2 = _interopRequireDefault(_invariant);\n\nfunction createConnector(React) {\n var Component = React.Component;\n var PropTypes = React.PropTypes;\n\n var storeShape = _utilsCreateStoreShape2['default'](PropTypes);\n\n return (function (_Component) {\n function Connector(props, context) {\n _classCallCheck(this, Connector);\n\n _Component.call(this, props, context);\n this.state = this.selectState(props, context);\n }\n\n _inherits(Connector, _Component);\n\n Connector.prototype.shouldComponentUpdate = function shouldComponentUpdate(nextProps, nextState) {\n return !this.isSliceEqual(this.state.slice, nextState.slice) || !_utilsShallowEqual2['default'](this.props, nextProps);\n };\n\n Connector.prototype.isSliceEqual = function isSliceEqual(slice, nextSlice) {\n var isRefEqual = slice === nextSlice;\n if (isRefEqual) {\n return true;\n } else if (typeof slice !== 'object' || typeof nextSlice !== 'object') {\n return isRefEqual;\n }\n return _utilsShallowEqual2['default'](slice, nextSlice);\n };\n\n Connector.prototype.componentDidMount = function componentDidMount() {\n this.unsubscribe = this.context.store.subscribe(this.handleChange.bind(this));\n this.handleChange();\n };\n\n Connector.prototype.componentWillReceiveProps = function componentWillReceiveProps(nextProps) {\n if (nextProps.select !== this.props.select) {\n // Force the state slice recalculation\n this.handleChange(nextProps);\n }\n };\n\n Connector.prototype.componentWillUnmount = function componentWillUnmount() {\n this.unsubscribe();\n };\n\n Connector.prototype.handleChange = function handleChange() {\n var props = arguments[0] === undefined ? this.props : arguments[0];\n\n var nextState = this.selectState(props, this.context);\n if (!this.isSliceEqual(this.state.slice, nextState.slice)) {\n this.setState(nextState);\n }\n };\n\n Connector.prototype.selectState = function selectState(props, context) {\n var state = context.store.getState();\n var slice = props.select(state);\n\n _invariant2['default'](_utilsIsPlainObject2['default'](slice), 'The return value of `select` prop must be an object. Instead received %s.', slice);\n\n return { slice: slice };\n };\n\n Connector.prototype.render = function render() {\n var children = this.props.children;\n var slice = this.state.slice;\n var dispatch = this.context.store.dispatch;\n\n return children(_extends({ dispatch: dispatch }, slice));\n };\n\n _createClass(Connector, null, [{\n key: 'contextTypes',\n value: {\n store: storeShape.isRequired\n },\n enumerable: true\n }, {\n key: 'propTypes',\n value: {\n children: PropTypes.func.isRequired,\n select: PropTypes.func.isRequired\n },\n enumerable: true\n }, {\n key: 'defaultProps',\n value: {\n select: function select(state) {\n return state;\n }\n },\n enumerable: true\n }]);\n\n return Connector;\n })(Component);\n}\n\nmodule.exports = exports['default'];\n\n/*****************\n ** WEBPACK FOOTER\n ** /Users/sergeylapin/~/react-redux/lib/components/createConnector.js\n ** module id = 273\n ** module chunks = 0\n **/\n//# sourceURL=webpack:////Users/sergeylapin/~/react-redux/lib/components/createConnector.js?");
|
||
|
||
/***/ },
|
||
/* 274 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("\"use strict\";\n\nexports.__esModule = true;\nexports[\"default\"] = shallowEqual;\n\nfunction shallowEqual(objA, objB) {\n if (objA === objB) {\n return true;\n }\n\n var keysA = Object.keys(objA);\n var keysB = Object.keys(objB);\n\n if (keysA.length !== keysB.length) {\n return false;\n }\n\n // Test for A's keys different from B.\n var hasOwn = Object.prototype.hasOwnProperty;\n for (var i = 0; i < keysA.length; i++) {\n if (!hasOwn.call(objB, keysA[i]) || objA[keysA[i]] !== objB[keysA[i]]) {\n return false;\n }\n }\n\n return true;\n}\n\nmodule.exports = exports[\"default\"];\n\n/*****************\n ** WEBPACK FOOTER\n ** /Users/sergeylapin/~/react-redux/lib/utils/shallowEqual.js\n ** module id = 274\n ** module chunks = 0\n **/\n//# sourceURL=webpack:////Users/sergeylapin/~/react-redux/lib/utils/shallowEqual.js?");
|
||
|
||
/***/ },
|
||
/* 275 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("'use strict';\n\nexports.__esModule = true;\nexports['default'] = isPlainObject;\n\nfunction isPlainObject(obj) {\n return obj ? typeof obj === 'object' && Object.getPrototypeOf(obj) === Object.prototype : false;\n}\n\nmodule.exports = exports['default'];\n\n/*****************\n ** WEBPACK FOOTER\n ** /Users/sergeylapin/~/react-redux/lib/utils/isPlainObject.js\n ** module id = 275\n ** module chunks = 0\n **/\n//# sourceURL=webpack:////Users/sergeylapin/~/react-redux/lib/utils/isPlainObject.js?");
|
||
|
||
/***/ },
|
||
/* 276 */
|
||
/***/ 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 invariant\n */\n\n'use strict';\n\n/**\n * Use invariant() to assert state which your program assumes to be true.\n *\n * Provide sprintf-style format (only %s is supported) and arguments\n * to provide information about what broke and what you were\n * expecting.\n *\n * The invariant message will be stripped in production, but the invariant\n * will remain to ensure logic does not differ in production.\n */\n\nvar invariant = function(condition, format, a, b, c, d, e, f) {\n if (process.env.NODE_ENV !== 'production') {\n if (format === undefined) {\n throw new Error('invariant requires an error message argument');\n }\n }\n\n if (!condition) {\n var error;\n if (format === undefined) {\n error = new Error(\n 'Minified exception occurred; use the non-minified dev environment ' +\n 'for the full error message and additional helpful warnings.'\n );\n } else {\n var args = [a, b, c, d, e, f];\n var argIndex = 0;\n error = new Error(\n 'Invariant Violation: ' +\n format.replace(/%s/g, function() { return args[argIndex++]; })\n );\n }\n\n error.framesToPop = 1; // we don't care about invariant's own frame\n throw error;\n }\n};\n\nmodule.exports = invariant;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62)))\n\n/*****************\n ** WEBPACK FOOTER\n ** /Users/sergeylapin/~/react-redux/~/invariant/browser.js\n ** module id = 276\n ** module chunks = 0\n **/\n//# sourceURL=webpack:////Users/sergeylapin/~/react-redux/~/invariant/browser.js?");
|
||
|
||
/***/ },
|
||
/* 277 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("'use strict';\n\nexports.__esModule = true;\n\nvar _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; };\n\nvar _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();\n\nexports['default'] = createConnectDecorator;\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; }\n\nvar _utilsGetDisplayName = __webpack_require__(272);\n\nvar _utilsGetDisplayName2 = _interopRequireDefault(_utilsGetDisplayName);\n\nvar _utilsShallowEqualScalar = __webpack_require__(278);\n\nvar _utilsShallowEqualScalar2 = _interopRequireDefault(_utilsShallowEqualScalar);\n\nfunction createConnectDecorator(React, Connector) {\n var Component = React.Component;\n\n return function connect(select) {\n return function (DecoratedComponent) {\n return (function (_Component) {\n function ConnectorDecorator() {\n _classCallCheck(this, ConnectorDecorator);\n\n _Component.apply(this, arguments);\n }\n\n _inherits(ConnectorDecorator, _Component);\n\n ConnectorDecorator.prototype.shouldComponentUpdate = function shouldComponentUpdate(nextProps) {\n return !_utilsShallowEqualScalar2['default'](this.props, nextProps);\n };\n\n ConnectorDecorator.prototype.render = function render() {\n var _this = this;\n\n return React.createElement(\n Connector,\n { select: function (state) {\n return select(state, _this.props);\n } },\n function (stuff) {\n return React.createElement(DecoratedComponent, _extends({}, stuff, _this.props));\n }\n );\n };\n\n _createClass(ConnectorDecorator, null, [{\n key: 'displayName',\n value: 'Connector(' + _utilsGetDisplayName2['default'](DecoratedComponent) + ')',\n enumerable: true\n }, {\n key: 'DecoratedComponent',\n value: DecoratedComponent,\n enumerable: true\n }]);\n\n return ConnectorDecorator;\n })(Component);\n };\n };\n}\n\nmodule.exports = exports['default'];\n\n/*****************\n ** WEBPACK FOOTER\n ** /Users/sergeylapin/~/react-redux/lib/components/createConnectDecorator.js\n ** module id = 277\n ** module chunks = 0\n **/\n//# sourceURL=webpack:////Users/sergeylapin/~/react-redux/lib/components/createConnectDecorator.js?");
|
||
|
||
/***/ },
|
||
/* 278 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("'use strict';\n\nexports.__esModule = true;\nexports['default'] = shallowEqualScalar;\n\nfunction shallowEqualScalar(objA, objB) {\n if (objA === objB) {\n return true;\n }\n\n if (typeof objA !== 'object' || objA === null || typeof objB !== 'object' || objB === null) {\n return false;\n }\n\n var keysA = Object.keys(objA);\n var keysB = Object.keys(objB);\n\n if (keysA.length !== keysB.length) {\n return false;\n }\n\n // Test for A's keys different from B.\n var hasOwn = Object.prototype.hasOwnProperty;\n for (var i = 0; i < keysA.length; i++) {\n if (!hasOwn.call(objB, keysA[i])) {\n return false;\n }\n\n var valA = objA[keysA[i]];\n var valB = objB[keysA[i]];\n\n if (valA !== valB || typeof valA === 'object' || typeof valB === 'object') {\n return false;\n }\n }\n\n return true;\n}\n\nmodule.exports = exports['default'];\n\n/*****************\n ** WEBPACK FOOTER\n ** /Users/sergeylapin/~/react-redux/lib/utils/shallowEqualScalar.js\n ** module id = 278\n ** module chunks = 0\n **/\n//# sourceURL=webpack:////Users/sergeylapin/~/react-redux/lib/utils/shallowEqualScalar.js?");
|
||
|
||
/***/ },
|
||
/* 279 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("// Core\n'use strict';\n\nexports.__esModule = true;\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nvar _createStore = __webpack_require__(282);\n\nvar _createStore2 = _interopRequireDefault(_createStore);\n\n// Utilities\n\nvar _utilsCompose = __webpack_require__(286);\n\nvar _utilsCompose2 = _interopRequireDefault(_utilsCompose);\n\nvar _utilsCombineReducers = __webpack_require__(287);\n\nvar _utilsCombineReducers2 = _interopRequireDefault(_utilsCombineReducers);\n\nvar _utilsBindActionCreators = __webpack_require__(280);\n\nvar _utilsBindActionCreators2 = _interopRequireDefault(_utilsBindActionCreators);\n\nvar _utilsApplyMiddleware = __webpack_require__(289);\n\nvar _utilsApplyMiddleware2 = _interopRequireDefault(_utilsApplyMiddleware);\n\nvar _utilsComposeMiddleware = __webpack_require__(290);\n\nvar _utilsComposeMiddleware2 = _interopRequireDefault(_utilsComposeMiddleware);\n\nexports.createStore = _createStore2['default'];\nexports.compose = _utilsCompose2['default'];\nexports.combineReducers = _utilsCombineReducers2['default'];\nexports.bindActionCreators = _utilsBindActionCreators2['default'];\nexports.applyMiddleware = _utilsApplyMiddleware2['default'];\nexports.composeMiddleware = _utilsComposeMiddleware2['default'];\n\n/*****************\n ** WEBPACK FOOTER\n ** /Users/sergeylapin/~/redux/lib/index.js\n ** module id = 279\n ** module chunks = 0\n **/\n//# sourceURL=webpack:////Users/sergeylapin/~/redux/lib/index.js?");
|
||
|
||
/***/ },
|
||
/* 280 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("'use strict';\n\nexports.__esModule = true;\nexports['default'] = bindActionCreators;\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nvar _utilsMapValues = __webpack_require__(281);\n\nvar _utilsMapValues2 = _interopRequireDefault(_utilsMapValues);\n\nfunction bindActionCreators(actionCreators, dispatch) {\n return _utilsMapValues2['default'](actionCreators, function (actionCreator) {\n return function () {\n return dispatch(actionCreator.apply(undefined, arguments));\n };\n });\n}\n\nmodule.exports = exports['default'];\n\n/*****************\n ** WEBPACK FOOTER\n ** /Users/sergeylapin/~/redux/lib/utils/bindActionCreators.js\n ** module id = 280\n ** module chunks = 0\n **/\n//# sourceURL=webpack:////Users/sergeylapin/~/redux/lib/utils/bindActionCreators.js?");
|
||
|
||
/***/ },
|
||
/* 281 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("\"use strict\";\n\nexports.__esModule = true;\nexports[\"default\"] = mapValues;\n\nfunction mapValues(obj, fn) {\n return Object.keys(obj).reduce(function (result, key) {\n result[key] = fn(obj[key], key);\n return result;\n }, {});\n}\n\nmodule.exports = exports[\"default\"];\n\n/*****************\n ** WEBPACK FOOTER\n ** /Users/sergeylapin/~/redux/lib/utils/mapValues.js\n ** module id = 281\n ** module chunks = 0\n **/\n//# sourceURL=webpack:////Users/sergeylapin/~/redux/lib/utils/mapValues.js?");
|
||
|
||
/***/ },
|
||
/* 282 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("'use strict';\n\nexports.__esModule = true;\nexports['default'] = createStore;\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nvar _Store = __webpack_require__(283);\n\nvar _Store2 = _interopRequireDefault(_Store);\n\nfunction createStore(reducer, initialState) {\n var store = new _Store2['default'](reducer, initialState);\n\n return {\n dispatch: store.dispatch.bind(store),\n subscribe: store.subscribe.bind(store),\n getState: store.getState.bind(store),\n getReducer: store.getReducer.bind(store),\n replaceReducer: store.replaceReducer.bind(store)\n };\n}\n\nmodule.exports = exports['default'];\n\n/*****************\n ** WEBPACK FOOTER\n ** /Users/sergeylapin/~/redux/lib/createStore.js\n ** module id = 282\n ** module chunks = 0\n **/\n//# sourceURL=webpack:////Users/sergeylapin/~/redux/lib/createStore.js?");
|
||
|
||
/***/ },
|
||
/* 283 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("'use strict';\n\nexports.__esModule = true;\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }\n\nvar _invariant = __webpack_require__(284);\n\nvar _invariant2 = _interopRequireDefault(_invariant);\n\nvar _utilsIsPlainObject = __webpack_require__(285);\n\nvar _utilsIsPlainObject2 = _interopRequireDefault(_utilsIsPlainObject);\n\n// Don't ever try to handle these action types in your code. They are private.\n// For any unknown actions, you must return the current state.\n// If the current state is undefined, you must return the initial state.\nvar ActionTypes = {\n INIT: '@@redux/INIT'\n};\n\nexports.ActionTypes = ActionTypes;\n\nvar Store = (function () {\n function Store(reducer, initialState) {\n _classCallCheck(this, Store);\n\n _invariant2['default'](typeof reducer === 'function', 'Expected the reducer to be a function.');\n\n this.state = initialState;\n this.listeners = [];\n this.replaceReducer(reducer);\n }\n\n Store.prototype.getReducer = function getReducer() {\n return this.reducer;\n };\n\n Store.prototype.replaceReducer = function replaceReducer(nextReducer) {\n this.reducer = nextReducer;\n this.dispatch({ type: ActionTypes.INIT });\n };\n\n Store.prototype.dispatch = function dispatch(action) {\n _invariant2['default'](_utilsIsPlainObject2['default'](action), 'Actions must be plain objects. Use custom middleware for async actions.');\n\n var reducer = this.reducer;\n\n this.state = reducer(this.state, action);\n this.listeners.forEach(function (listener) {\n return listener();\n });\n return action;\n };\n\n Store.prototype.getState = function getState() {\n return this.state;\n };\n\n Store.prototype.subscribe = function subscribe(listener) {\n var listeners = this.listeners;\n\n listeners.push(listener);\n\n return function unsubscribe() {\n var index = listeners.indexOf(listener);\n listeners.splice(index, 1);\n };\n };\n\n return Store;\n})();\n\nexports['default'] = Store;\n\n/*****************\n ** WEBPACK FOOTER\n ** /Users/sergeylapin/~/redux/lib/Store.js\n ** module id = 283\n ** module chunks = 0\n **/\n//# sourceURL=webpack:////Users/sergeylapin/~/redux/lib/Store.js?");
|
||
|
||
/***/ },
|
||
/* 284 */
|
||
/***/ 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 invariant\n */\n\n'use strict';\n\n/**\n * Use invariant() to assert state which your program assumes to be true.\n *\n * Provide sprintf-style format (only %s is supported) and arguments\n * to provide information about what broke and what you were\n * expecting.\n *\n * The invariant message will be stripped in production, but the invariant\n * will remain to ensure logic does not differ in production.\n */\n\nvar invariant = function(condition, format, a, b, c, d, e, f) {\n if (process.env.NODE_ENV !== 'production') {\n if (format === undefined) {\n throw new Error('invariant requires an error message argument');\n }\n }\n\n if (!condition) {\n var error;\n if (format === undefined) {\n error = new Error(\n 'Minified exception occurred; use the non-minified dev environment ' +\n 'for the full error message and additional helpful warnings.'\n );\n } else {\n var args = [a, b, c, d, e, f];\n var argIndex = 0;\n error = new Error(\n 'Invariant Violation: ' +\n format.replace(/%s/g, function() { return args[argIndex++]; })\n );\n }\n\n error.framesToPop = 1; // we don't care about invariant's own frame\n throw error;\n }\n};\n\nmodule.exports = invariant;\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(62)))\n\n/*****************\n ** WEBPACK FOOTER\n ** /Users/sergeylapin/~/redux/~/invariant/browser.js\n ** module id = 284\n ** module chunks = 0\n **/\n//# sourceURL=webpack:////Users/sergeylapin/~/redux/~/invariant/browser.js?");
|
||
|
||
/***/ },
|
||
/* 285 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("'use strict';\n\nexports.__esModule = true;\nexports['default'] = isPlainObject;\n\nfunction isPlainObject(obj) {\n return obj ? typeof obj === 'object' && Object.getPrototypeOf(obj) === Object.prototype : false;\n}\n\nmodule.exports = exports['default'];\n\n/*****************\n ** WEBPACK FOOTER\n ** /Users/sergeylapin/~/redux/lib/utils/isPlainObject.js\n ** module id = 285\n ** module chunks = 0\n **/\n//# sourceURL=webpack:////Users/sergeylapin/~/redux/lib/utils/isPlainObject.js?");
|
||
|
||
/***/ },
|
||
/* 286 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("/**\n * Composes functions from left to right\n * @param {...Function} funcs - Functions to compose\n * @return {Function}\n */\n\"use strict\";\n\nexports.__esModule = true;\nexports[\"default\"] = compose;\n\nfunction compose() {\n for (var _len = arguments.length, funcs = Array(_len), _key = 0; _key < _len; _key++) {\n funcs[_key] = arguments[_key];\n }\n\n return funcs.reduceRight(function (composed, f) {\n return f(composed);\n });\n}\n\nmodule.exports = exports[\"default\"];\n\n/*****************\n ** WEBPACK FOOTER\n ** /Users/sergeylapin/~/redux/lib/utils/compose.js\n ** module id = 286\n ** module chunks = 0\n **/\n//# sourceURL=webpack:////Users/sergeylapin/~/redux/lib/utils/compose.js?");
|
||
|
||
/***/ },
|
||
/* 287 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("'use strict';\n\nexports.__esModule = true;\nexports['default'] = combineReducers;\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nvar _utilsMapValues = __webpack_require__(281);\n\nvar _utilsMapValues2 = _interopRequireDefault(_utilsMapValues);\n\nvar _utilsPick = __webpack_require__(288);\n\nvar _utilsPick2 = _interopRequireDefault(_utilsPick);\n\nvar _invariant = __webpack_require__(284);\n\nvar _invariant2 = _interopRequireDefault(_invariant);\n\nvar _Store = __webpack_require__(283);\n\nfunction getErrorMessage(key, action) {\n var actionType = action && action.type;\n var actionName = actionType && '\"' + actionType + '\"' || 'an action';\n\n return 'Reducer \"' + key + '\" returned undefined handling ' + actionName + '. ' + 'To ignore an action, you must explicitly return the previous state.';\n}\n\nfunction combineReducers(reducers) {\n var finalReducers = _utilsPick2['default'](reducers, function (val) {\n return typeof val === 'function';\n });\n\n Object.keys(finalReducers).forEach(function (key) {\n var reducer = finalReducers[key];\n _invariant2['default'](typeof reducer(undefined, { type: _Store.ActionTypes.INIT }) !== 'undefined', 'Reducer \"' + key + '\" returned undefined during initialization. ' + 'If the state passed to the reducer is undefined, you must ' + 'explicitly return the initial state. The initial state may ' + 'not be undefined.');\n\n var type = Math.random().toString(36).substring(7).split('').join('.');\n _invariant2['default'](typeof reducer(undefined, { type: type }) !== 'undefined', 'Reducer \"' + key + '\" returned undefined when probed with a random type. ' + ('Don\\'t try to handle ' + _Store.ActionTypes.INIT + ' or other actions in \"redux/*\" ') + 'namespace. They are considered private. Instead, you must return the ' + 'current state for any unknown actions, unless it is undefined, ' + 'in which case you must return the initial state, regardless of the ' + 'action type. The initial state may not be undefined.');\n });\n\n return function composition(state, action) {\n if (state === undefined) state = {};\n\n return _utilsMapValues2['default'](finalReducers, function (reducer, key) {\n var newState = reducer(state[key], action);\n _invariant2['default'](typeof newState !== 'undefined', getErrorMessage(key, action));\n return newState;\n });\n };\n}\n\nmodule.exports = exports['default'];\n\n/*****************\n ** WEBPACK FOOTER\n ** /Users/sergeylapin/~/redux/lib/utils/combineReducers.js\n ** module id = 287\n ** module chunks = 0\n **/\n//# sourceURL=webpack:////Users/sergeylapin/~/redux/lib/utils/combineReducers.js?");
|
||
|
||
/***/ },
|
||
/* 288 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("\"use strict\";\n\nexports.__esModule = true;\nexports[\"default\"] = pick;\n\nfunction pick(obj, fn) {\n return Object.keys(obj).reduce(function (result, key) {\n if (fn(obj[key])) {\n result[key] = obj[key];\n }\n return result;\n }, {});\n}\n\nmodule.exports = exports[\"default\"];\n\n/*****************\n ** WEBPACK FOOTER\n ** /Users/sergeylapin/~/redux/lib/utils/pick.js\n ** module id = 288\n ** module chunks = 0\n **/\n//# sourceURL=webpack:////Users/sergeylapin/~/redux/lib/utils/pick.js?");
|
||
|
||
/***/ },
|
||
/* 289 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("'use strict';\n\nexports.__esModule = true;\n\nvar _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; };\n\nexports['default'] = applyMiddleware;\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nvar _compose = __webpack_require__(286);\n\nvar _compose2 = _interopRequireDefault(_compose);\n\nvar _composeMiddleware = __webpack_require__(290);\n\nvar _composeMiddleware2 = _interopRequireDefault(_composeMiddleware);\n\n/**\n * Creates a higher-order store that applies middleware to a store's dispatch.\n * Because middleware is potentially asynchronous, this should be the first\n * higher-order store in the composition chain.\n * @param {...Function} ...middlewares\n * @return {Function} A higher-order store\n */\n\nfunction applyMiddleware() {\n for (var _len = arguments.length, middlewares = Array(_len), _key = 0; _key < _len; _key++) {\n middlewares[_key] = arguments[_key];\n }\n\n return function (next) {\n return function () {\n var store = next.apply(undefined, arguments);\n var middleware = _composeMiddleware2['default'].apply(undefined, middlewares);\n\n function dispatch(action) {\n var methods = {\n dispatch: dispatch,\n getState: store.getState\n };\n\n return _compose2['default'](middleware(methods), store.dispatch)(action);\n }\n\n return _extends({}, store, {\n dispatch: dispatch\n });\n };\n };\n}\n\nmodule.exports = exports['default'];\n\n/*****************\n ** WEBPACK FOOTER\n ** /Users/sergeylapin/~/redux/lib/utils/applyMiddleware.js\n ** module id = 289\n ** module chunks = 0\n **/\n//# sourceURL=webpack:////Users/sergeylapin/~/redux/lib/utils/applyMiddleware.js?");
|
||
|
||
/***/ },
|
||
/* 290 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("'use strict';\n\nexports.__esModule = true;\nexports['default'] = composeMiddleware;\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nvar _compose = __webpack_require__(286);\n\nvar _compose2 = _interopRequireDefault(_compose);\n\n/**\n * Compose middleware from left to right\n * @param {...Function} middlewares\n * @return {Function}\n */\n\nfunction composeMiddleware() {\n for (var _len = arguments.length, middlewares = Array(_len), _key = 0; _key < _len; _key++) {\n middlewares[_key] = arguments[_key];\n }\n\n return function (methods) {\n return function (next) {\n return _compose2['default'].apply(undefined, middlewares.map(function (m) {\n return m(methods);\n }).concat([next]));\n };\n };\n}\n\nmodule.exports = exports['default'];\n\n/*****************\n ** WEBPACK FOOTER\n ** /Users/sergeylapin/~/redux/lib/utils/composeMiddleware.js\n ** module id = 290\n ** module chunks = 0\n **/\n//# sourceURL=webpack:////Users/sergeylapin/~/redux/lib/utils/composeMiddleware.js?");
|
||
|
||
/***/ },
|
||
/* 291 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("'use strict';\n\nexports.__esModule = true;\n\nvar _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; };\n\nvar _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }\n\nvar _react = __webpack_require__(115);\n\nvar _react2 = _interopRequireDefault(_react);\n\nvar _LogMonitorEntry = __webpack_require__(292);\n\nvar _LogMonitorEntry2 = _interopRequireDefault(_LogMonitorEntry);\n\nvar LogMonitor = (function () {\n function LogMonitor() {\n _classCallCheck(this, LogMonitor);\n\n window.addEventListener('keydown', this.handleKeyPress.bind(this));\n }\n\n LogMonitor.prototype.componentWillReceiveProps = function componentWillReceiveProps(nextProps) {\n var node = _react.findDOMNode(this);\n if (!node) {\n this.scrollDown = true;\n } else if (this.props.stagedActions.length < nextProps.stagedActions.length) {\n var scrollableNode = node.parentElement;\n var scrollTop = scrollableNode.scrollTop;\n var offsetHeight = scrollableNode.offsetHeight;\n var scrollHeight = scrollableNode.scrollHeight;\n\n this.scrollDown = Math.abs(scrollHeight - (scrollTop + offsetHeight)) < 20;\n } else {\n this.scrollDown = false;\n }\n };\n\n LogMonitor.prototype.componentDidUpdate = function componentDidUpdate() {\n var node = _react.findDOMNode(this);\n if (!node) {\n return;\n }\n\n if (this.scrollDown) {\n var scrollableNode = node.parentElement;\n var offsetHeight = scrollableNode.offsetHeight;\n var scrollHeight = scrollableNode.scrollHeight;\n\n scrollableNode.scrollTop = scrollHeight - offsetHeight;\n this.scrollDown = false;\n }\n };\n\n LogMonitor.prototype.handleRollback = function handleRollback() {\n this.props.rollback();\n };\n\n LogMonitor.prototype.handleSweep = function handleSweep() {\n this.props.sweep();\n };\n\n LogMonitor.prototype.handleCommit = function handleCommit() {\n this.props.commit();\n };\n\n LogMonitor.prototype.handleToggleAction = function handleToggleAction(index) {\n this.props.toggleAction(index);\n };\n\n LogMonitor.prototype.handleReset = function handleReset() {\n this.props.reset();\n };\n\n LogMonitor.prototype.handleKeyPress = function handleKeyPress(event) {\n var monitorState = this.props.monitorState;\n\n if (event.ctrlKey && event.keyCode === 72) {\n // Ctrl+H\n event.preventDefault();\n this.props.setMonitorState(_extends({}, monitorState, {\n isVisible: !monitorState.isVisible\n }));\n }\n };\n\n LogMonitor.prototype.render = function render() {\n var elements = [];\n var _props = this.props;\n var monitorState = _props.monitorState;\n var skippedActions = _props.skippedActions;\n var stagedActions = _props.stagedActions;\n var computedStates = _props.computedStates;\n var select = _props.select;\n\n if (!monitorState.isVisible) {\n return null;\n }\n\n for (var i = 0; i < stagedActions.length; i++) {\n var action = stagedActions[i];\n var _computedStates$i = computedStates[i];\n var state = _computedStates$i.state;\n var error = _computedStates$i.error;\n\n elements.push(_react2['default'].createElement(_LogMonitorEntry2['default'], { key: i,\n index: i,\n select: select,\n action: action,\n state: state,\n collapsed: skippedActions[i],\n error: error,\n onActionClick: this.handleToggleAction.bind(this) }));\n }\n\n return _react2['default'].createElement(\n 'div',\n { style: {\n fontFamily: 'monospace',\n position: 'relative',\n padding: '1rem'\n } },\n _react2['default'].createElement(\n 'div',\n null,\n _react2['default'].createElement(\n 'div',\n { style: {\n paddingBottom: '.5rem'\n } },\n _react2['default'].createElement(\n 'small',\n null,\n 'Press Ctrl+H to hide.'\n )\n ),\n _react2['default'].createElement(\n 'div',\n null,\n _react2['default'].createElement(\n 'a',\n { onClick: this.handleReset.bind(this),\n style: { textDecoration: 'underline', cursor: 'hand' } },\n _react2['default'].createElement(\n 'small',\n null,\n 'Reset'\n )\n )\n )\n ),\n elements,\n _react2['default'].createElement(\n 'div',\n null,\n computedStates.length > 1 && _react2['default'].createElement(\n 'a',\n { onClick: this.handleRollback.bind(this),\n style: { textDecoration: 'underline', cursor: 'hand' } },\n 'Rollback'\n ),\n Object.keys(skippedActions).some(function (key) {\n return skippedActions[key];\n }) && _react2['default'].createElement(\n 'span',\n null,\n ' • ',\n _react2['default'].createElement(\n 'a',\n { onClick: this.handleSweep.bind(this),\n style: { textDecoration: 'underline', cursor: 'hand' } },\n 'Sweep'\n )\n ),\n computedStates.length > 1 && _react2['default'].createElement(\n 'span',\n null,\n _react2['default'].createElement(\n 'span',\n null,\n ' • '\n ),\n _react2['default'].createElement(\n 'a',\n { onClick: this.handleCommit.bind(this),\n style: { textDecoration: 'underline', cursor: 'hand' } },\n 'Commit'\n )\n )\n )\n );\n };\n\n _createClass(LogMonitor, null, [{\n key: 'propTypes',\n value: {\n computedStates: _react.PropTypes.array.isRequired,\n currentStateIndex: _react.PropTypes.number.isRequired,\n monitorState: _react.PropTypes.object.isRequired,\n stagedActions: _react.PropTypes.array.isRequired,\n skippedActions: _react.PropTypes.object.isRequired,\n reset: _react.PropTypes.func.isRequired,\n commit: _react.PropTypes.func.isRequired,\n rollback: _react.PropTypes.func.isRequired,\n sweep: _react.PropTypes.func.isRequired,\n toggleAction: _react.PropTypes.func.isRequired,\n jumpToState: _react.PropTypes.func.isRequired,\n setMonitorState: _react.PropTypes.func.isRequired,\n select: _react.PropTypes.func.isRequired\n },\n enumerable: true\n }, {\n key: 'defaultProps',\n value: {\n select: function select(state) {\n return state;\n },\n monitorState: { isVisible: true }\n },\n enumerable: true\n }]);\n\n return LogMonitor;\n})();\n\nexports['default'] = LogMonitor;\nmodule.exports = exports['default'];\n\n/*****************\n ** WEBPACK FOOTER\n ** /Users/sergeylapin/lapanoid-redux-devtools/src/react/LogMonitor.js\n ** module id = 291\n ** module chunks = 0\n **/\n//# sourceURL=webpack:////Users/sergeylapin/lapanoid-redux-devtools/src/react/LogMonitor.js?");
|
||
|
||
/***/ },
|
||
/* 292 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("'use strict';\n\nexports.__esModule = true;\n\nvar _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }\n\nvar _react = __webpack_require__(115);\n\nvar _react2 = _interopRequireDefault(_react);\n\nfunction hsvToRgb(h, s, v) {\n var i = Math.floor(h);\n var f = h - i;\n var p = v * (1 - s);\n var q = v * (1 - f * s);\n var t = v * (1 - (1 - f) * s);\n var mod = i % 6;\n var r = [v, q, p, p, t, v][mod];\n var g = [t, v, v, q, p, p][mod];\n var b = [p, p, t, v, v, q][mod];\n\n return {\n r: Math.round(r * 255),\n g: Math.round(g * 255),\n b: Math.round(b * 255)\n };\n}\n\nfunction colorFromString(token) {\n var splitToken = token.split('');\n var finalToken = splitToken.concat(splitToken.reverse());\n\n var number = finalToken.reduce(function (sum, char) {\n return sum + char.charCodeAt(0);\n }, 0) * Math.abs(Math.sin(token.length));\n\n var h = Math.round(number * (180 / Math.PI) * token.length % 360);\n var s = number % 100 / 100;\n var v = 1;\n\n return hsvToRgb(h, s, v);\n}\n\nvar LogMonitorEntry = (function () {\n function LogMonitorEntry() {\n _classCallCheck(this, LogMonitorEntry);\n }\n\n LogMonitorEntry.prototype.printState = function printState(state, error) {\n var errorText = error;\n if (!errorText) {\n try {\n return JSON.stringify(this.props.select(state));\n } catch (err) {\n errorText = 'Error selecting state.';\n }\n }\n\n return _react2['default'].createElement(\n 'span',\n { style: {\n fontStyle: 'italic'\n } },\n '(',\n errorText,\n ')'\n );\n };\n\n LogMonitorEntry.prototype.handleActionClick = function handleActionClick() {\n var _props = this.props;\n var index = _props.index;\n var onActionClick = _props.onActionClick;\n\n if (index > 0) {\n onActionClick(index);\n }\n };\n\n LogMonitorEntry.prototype.render = function render() {\n var _props2 = this.props;\n var index = _props2.index;\n var error = _props2.error;\n var action = _props2.action;\n var state = _props2.state;\n var collapsed = _props2.collapsed;\n\n var _colorFromString = colorFromString(action.type);\n\n var r = _colorFromString.r;\n var g = _colorFromString.g;\n var b = _colorFromString.b;\n\n return _react2['default'].createElement(\n 'div',\n { style: {\n textDecoration: collapsed ? 'line-through' : 'none'\n } },\n _react2['default'].createElement(\n 'a',\n { onClick: this.handleActionClick.bind(this),\n style: {\n opacity: collapsed ? 0.5 : 1,\n marginTop: '1em',\n display: 'block',\n paddingBottom: '1em',\n paddingTop: '1em',\n color: 'rgb(' + r + ', ' + g + ', ' + b + ')',\n cursor: index > 0 ? 'hand' : 'default',\n WebkitUserSelect: 'none'\n } },\n JSON.stringify(action)\n ),\n !collapsed && _react2['default'].createElement(\n 'p',\n { style: {\n textAlign: 'center',\n transform: 'rotate(180deg)'\n } },\n '⇧'\n ),\n !collapsed && _react2['default'].createElement(\n 'div',\n { style: {\n paddingBottom: '1em',\n paddingTop: '1em',\n color: 'lightyellow'\n } },\n this.printState(state, error)\n ),\n _react2['default'].createElement('hr', { style: {\n marginBottom: '2em'\n } })\n );\n };\n\n _createClass(LogMonitorEntry, null, [{\n key: 'propTypes',\n value: {\n index: _react.PropTypes.number.isRequired,\n state: _react.PropTypes.object.isRequired,\n action: _react.PropTypes.object.isRequired,\n select: _react.PropTypes.func.isRequired,\n error: _react.PropTypes.string,\n onActionClick: _react.PropTypes.func.isRequired,\n collapsed: _react.PropTypes.bool\n },\n enumerable: true\n }]);\n\n return LogMonitorEntry;\n})();\n\nexports['default'] = LogMonitorEntry;\nmodule.exports = exports['default'];\n\n/*****************\n ** WEBPACK FOOTER\n ** /Users/sergeylapin/lapanoid-redux-devtools/src/react/LogMonitorEntry.js\n ** module id = 292\n ** module chunks = 0\n **/\n//# sourceURL=webpack:////Users/sergeylapin/lapanoid-redux-devtools/src/react/LogMonitorEntry.js?");
|
||
|
||
/***/ },
|
||
/* 293 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("'use strict';\n\nexports.__esModule = true;\n\nvar _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();\n\nexports.getDefaultStyle = getDefaultStyle;\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }\n\nvar _react = __webpack_require__(115);\n\nvar _react2 = _interopRequireDefault(_react);\n\nfunction getDefaultStyle(props) {\n var left = props.left;\n var right = props.right;\n var bottom = props.bottom;\n var top = props.top;\n\n if (typeof left === 'undefined' && typeof right === 'undefined') {\n right = true;\n }\n if (typeof top === 'undefined' && typeof bottom === 'undefined') {\n bottom = true;\n }\n\n return {\n position: 'fixed',\n zIndex: 999,\n fontSize: 17,\n overflow: 'scroll',\n opacity: 0.92,\n background: 'black',\n color: 'white',\n left: left ? 0 : undefined,\n right: right ? 0 : undefined,\n top: top ? 0 : undefined,\n bottom: bottom ? 0 : undefined,\n maxHeight: bottom && top ? '100%' : '20%',\n maxWidth: left && right ? '100%' : '20%',\n wordWrap: 'break-word'\n };\n}\n\nvar DebugPanel = (function () {\n function DebugPanel() {\n _classCallCheck(this, DebugPanel);\n }\n\n DebugPanel.prototype.render = function render() {\n return _react2['default'].createElement(\n 'div',\n { style: this.props.getStyle(this.props) },\n this.props.children\n );\n };\n\n _createClass(DebugPanel, null, [{\n key: 'propTypes',\n value: {\n left: _react.PropTypes.bool,\n right: _react.PropTypes.bool,\n bottom: _react.PropTypes.bool,\n top: _react.PropTypes.bool,\n getStyle: _react.PropTypes.func.isRequired\n },\n enumerable: true\n }, {\n key: 'defaultProps',\n value: {\n getStyle: getDefaultStyle\n },\n enumerable: true\n }]);\n\n return DebugPanel;\n})();\n\nexports['default'] = DebugPanel;\n\n/*****************\n ** WEBPACK FOOTER\n ** /Users/sergeylapin/lapanoid-redux-devtools/src/react/DebugPanel.js\n ** module id = 293\n ** module chunks = 0\n **/\n//# sourceURL=webpack:////Users/sergeylapin/lapanoid-redux-devtools/src/react/DebugPanel.js?");
|
||
|
||
/***/ },
|
||
/* 294 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/* WEBPACK VAR INJECTION */(function(module) {/* REACT HOT LOADER */ if (true) { (function () { var ReactHotAPI = __webpack_require__(217), RootInstanceProvider = __webpack_require__(59), ReactMount = __webpack_require__(61), React = __webpack_require__(115); module.makeHot = module.hot.data ? module.hot.data.makeHot : ReactHotAPI(function () { return RootInstanceProvider.getRootInstances(ReactMount); }, React); })(); } (function () {\n\n'use strict';\n\nexports.__esModule = true;\n\nfunction _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }\n\nvar _todos = __webpack_require__(295);\n\nexports.todos = _interopRequire(_todos);\n\n/* REACT HOT LOADER */ }).call(this); if (true) { (function () { module.hot.dispose(function (data) { data.makeHot = module.makeHot; }); if (module.exports && module.makeHot) { var makeExportsHot = __webpack_require__(254), foundReactClasses = false; if (makeExportsHot(module, __webpack_require__(115))) { foundReactClasses = true; } var shouldAcceptModule = true && foundReactClasses; if (shouldAcceptModule) { module.hot.accept(function (err) { if (err) { console.error(\"Cannot not apply hot update to \" + \"index.js\" + \": \" + err.message); } }); } } })(); }\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(34)(module)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./reducers/index.js\n ** module id = 294\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./reducers/index.js?");
|
||
|
||
/***/ },
|
||
/* 295 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("/* WEBPACK VAR INJECTION */(function(module) {/* REACT HOT LOADER */ if (true) { (function () { var ReactHotAPI = __webpack_require__(217), RootInstanceProvider = __webpack_require__(59), ReactMount = __webpack_require__(61), React = __webpack_require__(115); module.makeHot = module.hot.data ? module.hot.data.makeHot : ReactHotAPI(function () { return RootInstanceProvider.getRootInstances(ReactMount); }, React); })(); } (function () {\n\n'use strict';\n\nexports.__esModule = true;\n\nvar _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; };\n\nexports['default'] = todos;\n\nvar _constantsActionTypes = __webpack_require__(262);\n\nvar initialState = [{\n text: 'Use Redux',\n marked: false,\n id: 0\n}];\n\nfunction todos(state, action) {\n if (state === undefined) state = initialState;\n\n switch (action.type) {\n case _constantsActionTypes.ADD_TODO:\n return [{\n id: state.length === 0 ? 0 : state[0].id + 1,\n marked: false,\n text: action.text\n }].concat(state);\n\n case _constantsActionTypes.DELETE_TODO:\n return state.filter(function (todo) {\n return todo.id !== action.id;\n });\n\n case _constantsActionTypes.EDIT_TODO:\n return state.map(function (todo) {\n return todo.id === action.id ? _extends({}, todo, { text: action.text }) : todo;\n });\n\n case _constantsActionTypes.MARK_TODO:\n return state.map(function (todo) {\n return todo.id === action.id ? _extends({}, todo, { marked: !todo.marked }) : todo;\n });\n\n case _constantsActionTypes.MARK_ALL:\n var areAllMarked = state.every(function (todo) {\n return todo.marked;\n });\n return state.map(function (todo) {\n return _extends({}, todo, {\n marked: !areAllMarked\n });\n });\n\n case _constantsActionTypes.CLEAR_MARKED:\n return state.filter(function (todo) {\n return todo.marked === false;\n });\n\n default:\n return state;\n }\n}\n\nmodule.exports = exports['default'];\n\n/* REACT HOT LOADER */ }).call(this); if (true) { (function () { module.hot.dispose(function (data) { data.makeHot = module.makeHot; }); if (module.exports && module.makeHot) { var makeExportsHot = __webpack_require__(254), foundReactClasses = false; if (makeExportsHot(module, __webpack_require__(115))) { foundReactClasses = true; } var shouldAcceptModule = true && foundReactClasses; if (shouldAcceptModule) { module.hot.accept(function (err) { if (err) { console.error(\"Cannot not apply hot update to \" + \"todos.js\" + \": \" + err.message); } }); } } })(); }\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(34)(module)))\n\n/*****************\n ** WEBPACK FOOTER\n ** ./reducers/todos.js\n ** module id = 295\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./reducers/todos.js?");
|
||
|
||
/***/ },
|
||
/* 296 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
eval("// style-loader: Adds some css to the DOM by adding a <style> tag\n\n// load the styles\nvar content = __webpack_require__(297);\nif(typeof content === 'string') content = [[module.id, content, '']];\n// add the styles to the DOM\nvar update = __webpack_require__(298)(content, {});\nif(content.locals) module.exports = content.locals;\n// Hot Module Replacement\nif(true) {\n\t// When the styles change, update the <style> tags\n\tif(!content.locals) {\n\t\tmodule.hot.accept(297, function() {\n\t\t\tvar newContent = __webpack_require__(297);\n\t\t\tif(typeof newContent === 'string') newContent = [[module.id, newContent, '']];\n\t\t\tupdate(newContent);\n\t\t});\n\t}\n\t// When the module is disposed, remove the <style> tags\n\tmodule.hot.dispose(function() { update(); });\n}\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/todomvc-app-css/index.css\n ** module id = 296\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/todomvc-app-css/index.css?");
|
||
|
||
/***/ },
|
||
/* 297 */
|
||
/***/ function(module, exports) {
|
||
|
||
eval("module.exports = \"html,\\nbody {\\n\\tmargin: 0;\\n\\tpadding: 0;\\n}\\n\\nbutton {\\n\\tmargin: 0;\\n\\tpadding: 0;\\n\\tborder: 0;\\n\\tbackground: none;\\n\\tfont-size: 100%;\\n\\tvertical-align: baseline;\\n\\tfont-family: inherit;\\n\\tfont-weight: inherit;\\n\\tcolor: inherit;\\n\\t-webkit-appearance: none;\\n\\tappearance: none;\\n\\t-webkit-font-smoothing: antialiased;\\n\\t-moz-font-smoothing: antialiased;\\n\\tfont-smoothing: antialiased;\\n}\\n\\nbody {\\n\\tfont: 14px 'Helvetica Neue', Helvetica, Arial, sans-serif;\\n\\tline-height: 1.4em;\\n\\tbackground: #f5f5f5;\\n\\tcolor: #4d4d4d;\\n\\tmin-width: 230px;\\n\\tmax-width: 550px;\\n\\tmargin: 0 auto;\\n\\t-webkit-font-smoothing: antialiased;\\n\\t-moz-font-smoothing: antialiased;\\n\\tfont-smoothing: antialiased;\\n\\tfont-weight: 300;\\n}\\n\\nbutton,\\ninput[type=\\\"checkbox\\\"] {\\n\\toutline: none;\\n}\\n\\n.hidden {\\n\\tdisplay: none;\\n}\\n\\n.todoapp {\\n\\tbackground: #fff;\\n\\tmargin: 130px 0 40px 0;\\n\\tposition: relative;\\n\\tbox-shadow: 0 2px 4px 0 rgba(0, 0, 0, 0.2),\\n\\t 0 25px 50px 0 rgba(0, 0, 0, 0.1);\\n}\\n\\n.todoapp input::-webkit-input-placeholder {\\n\\tfont-style: italic;\\n\\tfont-weight: 300;\\n\\tcolor: #e6e6e6;\\n}\\n\\n.todoapp input::-moz-placeholder {\\n\\tfont-style: italic;\\n\\tfont-weight: 300;\\n\\tcolor: #e6e6e6;\\n}\\n\\n.todoapp input::input-placeholder {\\n\\tfont-style: italic;\\n\\tfont-weight: 300;\\n\\tcolor: #e6e6e6;\\n}\\n\\n.todoapp h1 {\\n\\tposition: absolute;\\n\\ttop: -155px;\\n\\twidth: 100%;\\n\\tfont-size: 100px;\\n\\tfont-weight: 100;\\n\\ttext-align: center;\\n\\tcolor: rgba(175, 47, 47, 0.15);\\n\\t-webkit-text-rendering: optimizeLegibility;\\n\\t-moz-text-rendering: optimizeLegibility;\\n\\ttext-rendering: optimizeLegibility;\\n}\\n\\n.new-todo,\\n.edit {\\n\\tposition: relative;\\n\\tmargin: 0;\\n\\twidth: 100%;\\n\\tfont-size: 24px;\\n\\tfont-family: inherit;\\n\\tfont-weight: inherit;\\n\\tline-height: 1.4em;\\n\\tborder: 0;\\n\\toutline: none;\\n\\tcolor: inherit;\\n\\tpadding: 6px;\\n\\tborder: 1px solid #999;\\n\\tbox-shadow: inset 0 -1px 5px 0 rgba(0, 0, 0, 0.2);\\n\\tbox-sizing: border-box;\\n\\t-webkit-font-smoothing: antialiased;\\n\\t-moz-font-smoothing: antialiased;\\n\\tfont-smoothing: antialiased;\\n}\\n\\n.new-todo {\\n\\tpadding: 16px 16px 16px 60px;\\n\\tborder: none;\\n\\tbackground: rgba(0, 0, 0, 0.003);\\n\\tbox-shadow: inset 0 -2px 1px rgba(0,0,0,0.03);\\n}\\n\\n.main {\\n\\tposition: relative;\\n\\tz-index: 2;\\n\\tborder-top: 1px solid #e6e6e6;\\n}\\n\\nlabel[for='toggle-all'] {\\n\\tdisplay: none;\\n}\\n\\n.toggle-all {\\n\\tposition: absolute;\\n\\ttop: -55px;\\n\\tleft: -12px;\\n\\twidth: 60px;\\n\\theight: 34px;\\n\\ttext-align: center;\\n\\tborder: none; /* Mobile Safari */\\n}\\n\\n.toggle-all:before {\\n\\tcontent: '❯';\\n\\tfont-size: 22px;\\n\\tcolor: #e6e6e6;\\n\\tpadding: 10px 27px 10px 27px;\\n}\\n\\n.toggle-all:checked:before {\\n\\tcolor: #737373;\\n}\\n\\n.todo-list {\\n\\tmargin: 0;\\n\\tpadding: 0;\\n\\tlist-style: none;\\n}\\n\\n.todo-list li {\\n\\tposition: relative;\\n\\tfont-size: 24px;\\n\\tborder-bottom: 1px solid #ededed;\\n}\\n\\n.todo-list li:last-child {\\n\\tborder-bottom: none;\\n}\\n\\n.todo-list li.editing {\\n\\tborder-bottom: none;\\n\\tpadding: 0;\\n}\\n\\n.todo-list li.editing .edit {\\n\\tdisplay: block;\\n\\twidth: 506px;\\n\\tpadding: 13px 17px 12px 17px;\\n\\tmargin: 0 0 0 43px;\\n}\\n\\n.todo-list li.editing .view {\\n\\tdisplay: none;\\n}\\n\\n.todo-list li .toggle {\\n\\ttext-align: center;\\n\\twidth: 40px;\\n\\t/* auto, since non-WebKit browsers doesn't support input styling */\\n\\theight: auto;\\n\\tposition: absolute;\\n\\ttop: 0;\\n\\tbottom: 0;\\n\\tmargin: auto 0;\\n\\tborder: none; /* Mobile Safari */\\n\\t-webkit-appearance: none;\\n\\tappearance: none;\\n}\\n\\n.todo-list li .toggle:after {\\n\\tcontent: url('data:image/svg+xml;utf8,<svg xmlns=\\\"http://www.w3.org/2000/svg\\\" width=\\\"40\\\" height=\\\"40\\\" viewBox=\\\"-10 -18 100 135\\\"><circle cx=\\\"50\\\" cy=\\\"50\\\" r=\\\"50\\\" fill=\\\"none\\\" stroke=\\\"#ededed\\\" stroke-width=\\\"3\\\"/></svg>');\\n}\\n\\n.todo-list li .toggle:checked:after {\\n\\tcontent: url('data:image/svg+xml;utf8,<svg xmlns=\\\"http://www.w3.org/2000/svg\\\" width=\\\"40\\\" height=\\\"40\\\" viewBox=\\\"-10 -18 100 135\\\"><circle cx=\\\"50\\\" cy=\\\"50\\\" r=\\\"50\\\" fill=\\\"none\\\" stroke=\\\"#bddad5\\\" stroke-width=\\\"3\\\"/><path fill=\\\"#5dc2af\\\" d=\\\"M72 25L42 71 27 56l-4 4 20 20 34-52z\\\"/></svg>');\\n}\\n\\n.todo-list li label {\\n\\twhite-space: pre;\\n\\tword-break: break-word;\\n\\tpadding: 15px 60px 15px 15px;\\n\\tmargin-left: 45px;\\n\\tdisplay: block;\\n\\tline-height: 1.2;\\n\\ttransition: color 0.4s;\\n}\\n\\n.todo-list li.completed label {\\n\\tcolor: #d9d9d9;\\n\\ttext-decoration: line-through;\\n}\\n\\n.todo-list li .destroy {\\n\\tdisplay: none;\\n\\tposition: absolute;\\n\\ttop: 0;\\n\\tright: 10px;\\n\\tbottom: 0;\\n\\twidth: 40px;\\n\\theight: 40px;\\n\\tmargin: auto 0;\\n\\tfont-size: 30px;\\n\\tcolor: #cc9a9a;\\n\\tmargin-bottom: 11px;\\n\\ttransition: color 0.2s ease-out;\\n}\\n\\n.todo-list li .destroy:hover {\\n\\tcolor: #af5b5e;\\n}\\n\\n.todo-list li .destroy:after {\\n\\tcontent: '×';\\n}\\n\\n.todo-list li:hover .destroy {\\n\\tdisplay: block;\\n}\\n\\n.todo-list li .edit {\\n\\tdisplay: none;\\n}\\n\\n.todo-list li.editing:last-child {\\n\\tmargin-bottom: -1px;\\n}\\n\\n.footer {\\n\\tcolor: #777;\\n\\tpadding: 10px 15px;\\n\\theight: 20px;\\n\\ttext-align: center;\\n\\tborder-top: 1px solid #e6e6e6;\\n}\\n\\n.footer:before {\\n\\tcontent: '';\\n\\tposition: absolute;\\n\\tright: 0;\\n\\tbottom: 0;\\n\\tleft: 0;\\n\\theight: 50px;\\n\\toverflow: hidden;\\n\\tbox-shadow: 0 1px 1px rgba(0, 0, 0, 0.2),\\n\\t 0 8px 0 -3px #f6f6f6,\\n\\t 0 9px 1px -3px rgba(0, 0, 0, 0.2),\\n\\t 0 16px 0 -6px #f6f6f6,\\n\\t 0 17px 2px -6px rgba(0, 0, 0, 0.2);\\n}\\n\\n.todo-count {\\n\\tfloat: left;\\n\\ttext-align: left;\\n}\\n\\n.todo-count strong {\\n\\tfont-weight: 300;\\n}\\n\\n.filters {\\n\\tmargin: 0;\\n\\tpadding: 0;\\n\\tlist-style: none;\\n\\tposition: absolute;\\n\\tright: 0;\\n\\tleft: 0;\\n}\\n\\n.filters li {\\n\\tdisplay: inline;\\n}\\n\\n.filters li a {\\n\\tcolor: inherit;\\n\\tmargin: 3px;\\n\\tpadding: 3px 7px;\\n\\ttext-decoration: none;\\n\\tborder: 1px solid transparent;\\n\\tborder-radius: 3px;\\n}\\n\\n.filters li a.selected,\\n.filters li a:hover {\\n\\tborder-color: rgba(175, 47, 47, 0.1);\\n}\\n\\n.filters li a.selected {\\n\\tborder-color: rgba(175, 47, 47, 0.2);\\n}\\n\\n.clear-completed,\\nhtml .clear-completed:active {\\n\\tfloat: right;\\n\\tposition: relative;\\n\\tline-height: 20px;\\n\\ttext-decoration: none;\\n\\tcursor: pointer;\\n\\tposition: relative;\\n}\\n\\n.clear-completed:hover {\\n\\ttext-decoration: underline;\\n}\\n\\n.info {\\n\\tmargin: 65px auto 0;\\n\\tcolor: #bfbfbf;\\n\\tfont-size: 10px;\\n\\ttext-shadow: 0 1px 0 rgba(255, 255, 255, 0.5);\\n\\ttext-align: center;\\n}\\n\\n.info p {\\n\\tline-height: 1;\\n}\\n\\n.info a {\\n\\tcolor: inherit;\\n\\ttext-decoration: none;\\n\\tfont-weight: 400;\\n}\\n\\n.info a:hover {\\n\\ttext-decoration: underline;\\n}\\n\\n/*\\n\\tHack to remove background from Mobile Safari.\\n\\tCan't use it globally since it destroys checkboxes in Firefox\\n*/\\n@media screen and (-webkit-min-device-pixel-ratio:0) {\\n\\t.toggle-all,\\n\\t.todo-list li .toggle {\\n\\t\\tbackground: none;\\n\\t}\\n\\n\\t.todo-list li .toggle {\\n\\t\\theight: 40px;\\n\\t}\\n\\n\\t.toggle-all {\\n\\t\\t-webkit-transform: rotate(90deg);\\n\\t\\ttransform: rotate(90deg);\\n\\t\\t-webkit-appearance: none;\\n\\t\\tappearance: none;\\n\\t}\\n}\\n\\n@media (max-width: 430px) {\\n\\t.footer {\\n\\t\\theight: 50px;\\n\\t}\\n\\n\\t.filters {\\n\\t\\tbottom: 10px;\\n\\t}\\n}\\n\"\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/raw-loader!./~/todomvc-app-css/index.css\n ** module id = 297\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/todomvc-app-css/index.css?./~/raw-loader");
|
||
|
||
/***/ },
|
||
/* 298 */
|
||
/***/ 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\nvar stylesInDom = {},\r\n\tmemoize = function(fn) {\r\n\t\tvar memo;\r\n\t\treturn function () {\r\n\t\t\tif (typeof memo === \"undefined\") memo = fn.apply(this, arguments);\r\n\t\t\treturn memo;\r\n\t\t};\r\n\t},\r\n\tisOldIE = memoize(function() {\r\n\t\treturn /msie [6-9]\\b/.test(window.navigator.userAgent.toLowerCase());\r\n\t}),\r\n\tgetHeadElement = memoize(function () {\r\n\t\treturn document.head || document.getElementsByTagName(\"head\")[0];\r\n\t}),\r\n\tsingletonElement = null,\r\n\tsingletonCounter = 0;\r\n\r\nmodule.exports = function(list, options) {\r\n\tif(false) {\r\n\t\tif(typeof document !== \"object\") throw new Error(\"The style-loader cannot be used in a non-browser environment\");\r\n\t}\r\n\r\n\toptions = options || {};\r\n\t// Force single-tag solution on IE6-9, which has a hard limit on the # of <style>\r\n\t// tags it will allow on a page\r\n\tif (typeof options.singleton === \"undefined\") options.singleton = isOldIE();\r\n\r\n\tvar styles = listToStyles(list);\r\n\taddStylesToDom(styles, options);\r\n\r\n\treturn function update(newList) {\r\n\t\tvar mayRemove = [];\r\n\t\tfor(var i = 0; i < styles.length; i++) {\r\n\t\t\tvar item = styles[i];\r\n\t\t\tvar domStyle = stylesInDom[item.id];\r\n\t\t\tdomStyle.refs--;\r\n\t\t\tmayRemove.push(domStyle);\r\n\t\t}\r\n\t\tif(newList) {\r\n\t\t\tvar newStyles = listToStyles(newList);\r\n\t\t\taddStylesToDom(newStyles, options);\r\n\t\t}\r\n\t\tfor(var i = 0; i < mayRemove.length; i++) {\r\n\t\t\tvar domStyle = mayRemove[i];\r\n\t\t\tif(domStyle.refs === 0) {\r\n\t\t\t\tfor(var j = 0; j < domStyle.parts.length; j++)\r\n\t\t\t\t\tdomStyle.parts[j]();\r\n\t\t\t\tdelete stylesInDom[domStyle.id];\r\n\t\t\t}\r\n\t\t}\r\n\t};\r\n}\r\n\r\nfunction addStylesToDom(styles, options) {\r\n\tfor(var i = 0; i < styles.length; i++) {\r\n\t\tvar item = styles[i];\r\n\t\tvar domStyle = stylesInDom[item.id];\r\n\t\tif(domStyle) {\r\n\t\t\tdomStyle.refs++;\r\n\t\t\tfor(var j = 0; j < domStyle.parts.length; j++) {\r\n\t\t\t\tdomStyle.parts[j](item.parts[j]);\r\n\t\t\t}\r\n\t\t\tfor(; j < item.parts.length; j++) {\r\n\t\t\t\tdomStyle.parts.push(addStyle(item.parts[j], options));\r\n\t\t\t}\r\n\t\t} else {\r\n\t\t\tvar parts = [];\r\n\t\t\tfor(var j = 0; j < item.parts.length; j++) {\r\n\t\t\t\tparts.push(addStyle(item.parts[j], options));\r\n\t\t\t}\r\n\t\t\tstylesInDom[item.id] = {id: item.id, refs: 1, parts: parts};\r\n\t\t}\r\n\t}\r\n}\r\n\r\nfunction listToStyles(list) {\r\n\tvar styles = [];\r\n\tvar newStyles = {};\r\n\tfor(var i = 0; i < list.length; i++) {\r\n\t\tvar item = list[i];\r\n\t\tvar id = item[0];\r\n\t\tvar css = item[1];\r\n\t\tvar media = item[2];\r\n\t\tvar sourceMap = item[3];\r\n\t\tvar part = {css: css, media: media, sourceMap: sourceMap};\r\n\t\tif(!newStyles[id])\r\n\t\t\tstyles.push(newStyles[id] = {id: id, parts: [part]});\r\n\t\telse\r\n\t\t\tnewStyles[id].parts.push(part);\r\n\t}\r\n\treturn styles;\r\n}\r\n\r\nfunction createStyleElement() {\r\n\tvar styleElement = document.createElement(\"style\");\r\n\tvar head = getHeadElement();\r\n\tstyleElement.type = \"text/css\";\r\n\thead.appendChild(styleElement);\r\n\treturn styleElement;\r\n}\r\n\r\nfunction createLinkElement() {\r\n\tvar linkElement = document.createElement(\"link\");\r\n\tvar head = getHeadElement();\r\n\tlinkElement.rel = \"stylesheet\";\r\n\thead.appendChild(linkElement);\r\n\treturn linkElement;\r\n}\r\n\r\nfunction addStyle(obj, options) {\r\n\tvar styleElement, update, remove;\r\n\r\n\tif (options.singleton) {\r\n\t\tvar styleIndex = singletonCounter++;\r\n\t\tstyleElement = singletonElement || (singletonElement = createStyleElement());\r\n\t\tupdate = applyToSingletonTag.bind(null, styleElement, styleIndex, false);\r\n\t\tremove = applyToSingletonTag.bind(null, styleElement, styleIndex, true);\r\n\t} else if(obj.sourceMap &&\r\n\t\ttypeof URL === \"function\" &&\r\n\t\ttypeof URL.createObjectURL === \"function\" &&\r\n\t\ttypeof URL.revokeObjectURL === \"function\" &&\r\n\t\ttypeof Blob === \"function\" &&\r\n\t\ttypeof btoa === \"function\") {\r\n\t\tstyleElement = createLinkElement();\r\n\t\tupdate = updateLink.bind(null, styleElement);\r\n\t\tremove = function() {\r\n\t\t\tstyleElement.parentNode.removeChild(styleElement);\r\n\t\t\tif(styleElement.href)\r\n\t\t\t\tURL.revokeObjectURL(styleElement.href);\r\n\t\t};\r\n\t} else {\r\n\t\tstyleElement = createStyleElement();\r\n\t\tupdate = applyToTag.bind(null, styleElement);\r\n\t\tremove = function() {\r\n\t\t\tstyleElement.parentNode.removeChild(styleElement);\r\n\t\t};\r\n\t}\r\n\r\n\tupdate(obj);\r\n\r\n\treturn function updateStyle(newObj) {\r\n\t\tif(newObj) {\r\n\t\t\tif(newObj.css === obj.css && newObj.media === obj.media && newObj.sourceMap === obj.sourceMap)\r\n\t\t\t\treturn;\r\n\t\t\tupdate(obj = newObj);\r\n\t\t} else {\r\n\t\t\tremove();\r\n\t\t}\r\n\t};\r\n}\r\n\r\nvar replaceText = (function () {\r\n\tvar textStore = [];\r\n\r\n\treturn function (index, replacement) {\r\n\t\ttextStore[index] = replacement;\r\n\t\treturn textStore.filter(Boolean).join('\\n');\r\n\t};\r\n})();\r\n\r\nfunction applyToSingletonTag(styleElement, index, remove, obj) {\r\n\tvar css = remove ? \"\" : obj.css;\r\n\r\n\tif (styleElement.styleSheet) {\r\n\t\tstyleElement.styleSheet.cssText = replaceText(index, css);\r\n\t} else {\r\n\t\tvar cssNode = document.createTextNode(css);\r\n\t\tvar childNodes = styleElement.childNodes;\r\n\t\tif (childNodes[index]) styleElement.removeChild(childNodes[index]);\r\n\t\tif (childNodes.length) {\r\n\t\t\tstyleElement.insertBefore(cssNode, childNodes[index]);\r\n\t\t} else {\r\n\t\t\tstyleElement.appendChild(cssNode);\r\n\t\t}\r\n\t}\r\n}\r\n\r\nfunction applyToTag(styleElement, obj) {\r\n\tvar css = obj.css;\r\n\tvar media = obj.media;\r\n\tvar sourceMap = obj.sourceMap;\r\n\r\n\tif(media) {\r\n\t\tstyleElement.setAttribute(\"media\", media)\r\n\t}\r\n\r\n\tif(styleElement.styleSheet) {\r\n\t\tstyleElement.styleSheet.cssText = css;\r\n\t} else {\r\n\t\twhile(styleElement.firstChild) {\r\n\t\t\tstyleElement.removeChild(styleElement.firstChild);\r\n\t\t}\r\n\t\tstyleElement.appendChild(document.createTextNode(css));\r\n\t}\r\n}\r\n\r\nfunction updateLink(linkElement, obj) {\r\n\tvar css = obj.css;\r\n\tvar media = obj.media;\r\n\tvar sourceMap = obj.sourceMap;\r\n\r\n\tif(sourceMap) {\r\n\t\t// http://stackoverflow.com/a/26603875\r\n\t\tcss += \"\\n/*# sourceMappingURL=data:application/json;base64,\" + btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap)))) + \" */\";\r\n\t}\r\n\r\n\tvar blob = new Blob([css], { type: \"text/css\" });\r\n\r\n\tvar oldSrc = linkElement.href;\r\n\r\n\tlinkElement.href = URL.createObjectURL(blob);\r\n\r\n\tif(oldSrc)\r\n\t\tURL.revokeObjectURL(oldSrc);\r\n}\r\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/style-loader/addStyles.js\n ** module id = 298\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./~/style-loader/addStyles.js?");
|
||
|
||
/***/ }
|
||
/******/ ]); |