From 22866d6a5c103110ff0690b2eca723cbb19b5bd6 Mon Sep 17 00:00:00 2001 From: mika-n Date: Sun, 7 Jul 2019 00:47:54 +0300 Subject: [PATCH] New customizable output curve functionality. User can create any kind of output curve via a bezier curve editor (external HTML web app in BezierCurveEditor folder). --- DS4Windows/BezierCurveEditor/BezierCurve.cs | 250 + DS4Windows/BezierCurveEditor/build.js | 10114 ++++++++++++++++++ DS4Windows/BezierCurveEditor/index.html | 10 + DS4Windows/DS4Control/Mapping.cs | 303 +- DS4Windows/DS4Control/ScpUtil.cs | 221 +- DS4Windows/DS4Forms/Options.Designer.cs | 22 +- DS4Windows/DS4Forms/Options.cs | 24 +- DS4Windows/DS4Forms/Options.resx | 54 +- DS4Windows/DS4Windows.csproj | 10 + 9 files changed, 10638 insertions(+), 370 deletions(-) create mode 100644 DS4Windows/BezierCurveEditor/BezierCurve.cs create mode 100644 DS4Windows/BezierCurveEditor/build.js create mode 100644 DS4Windows/BezierCurveEditor/index.html diff --git a/DS4Windows/BezierCurveEditor/BezierCurve.cs b/DS4Windows/BezierCurveEditor/BezierCurve.cs new file mode 100644 index 0000000..71401ed --- /dev/null +++ b/DS4Windows/BezierCurveEditor/BezierCurve.cs @@ -0,0 +1,250 @@ +/* MIT License + * + * KeySpline - use bezier curve for transition easing function + * Copyright (c) 2012 Gaetan Renaudeau (GRE) + * + * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +*/ +/* KeySpline - use bezier curve for transition easing function is inspired from Firefox's nsSMILKeySpline.cpp */ + +/* +* This file contains the original bezier curve code (see comments above) and calculations ported as C# code. The original code was in JavaScript. +* +* This file has few customizations and optimizations for the needs of DS4Windows application (see https://github.com/Ryochan7/DS4Windows). +* MIT License. Permission is hereby granted, free of charge, to any person to do whatever they want with this C# ported version of BezierCurve calculation code +* as long usage is in compliance with the above shown original license, also. +* +* Copyright (c) 2019, MIKA-N (https://github.com/mika-n). +* +* The original JavaScript version of bezier easing made by GRE (https://github.com/gre/bezier-easing). +* +* Usage: +* BezierCurve.InitBezierCurve = Initialize bezier curve and output lookup table. Must be called at least once before calling GetBezierEasing method (or accessing lookup table directly) to re-map analog axis input. +* BezierCurve.GetBezierEasing = Return re-mapped output value for an input axis value (or alternatively directly accessing the lookup table BezierCurve.arrayBezierLUT[inputVal] if even tiny CPU cycles matter) +* +*/ +using System; + +namespace DS4Windows +{ + public class BezierCurve + { + public enum AxisType { LSRS, L2R2, SA }; + + private static int kSplineTableSize = 11; + private static double kSampleStepSize = 1.0 / (kSplineTableSize - 1.0); + private double[] arraySampleValues; + + // These values are established by empiricism with tests (tradeoff: performance VS precision) (comment by GRE) + private static int NEWTON_ITERATIONS = 4; + private static double NEWTON_MIN_SLOPE = 0.001; + private static double SUBDIVISION_PRECISION = 0.0000001; + private static int SUBDIVISION_MAX_ITERATIONS = 10; + + private double mX1 = 0, mY1 = 0, mX2 = 0, mY2 = 0; // Bezier curve definition (0, 0, 0, 0 = Linear) + + // Set or Get string representation of the bezier curve definition value (Note! Set doesn't initialize the lookup table. InitBezierCurve needs to be called to actually initalize the calculation) + public string AsString + { + get { return ($"{mX1}, {mY1}, {mX2}, {mY2}"); } + set + { + // Set bezier curve defintion from a string value (4 comma separated decimals). If any of the string values are invalid then set curve as linear "zero" curve + string[] bezierDef = value.Split(new Char[] { ',' }, 4); + if (bezierDef.Length < 4 || !Double.TryParse(bezierDef[0], out mX1) || !Double.TryParse(bezierDef[1], out mY1) || !Double.TryParse(bezierDef[2], out mX2) || !Double.TryParse(bezierDef[3], out mY2) ) + mX1 = mY1 = mX2 = mY2 = 0; + } + } + + // Custom definition set by DS4Windows options screens. This string is not validated, but AsString property returns validated value + public string CustomDefinition { get; set; } + public string ToString() { return this.CustomDefinition; } + + public AxisType axisType; + + // Lookup result table is always either in 0..128 or 0..255 range depending on the DS4 analog axis range. LUT table set as public to let DS4Win reading thread to access it directly (every CPU cycle matters) + public byte[] arrayBezierLUT = null; + + public BezierCurve() + { + CustomDefinition = ""; + } + + public bool InitBezierCurve(string bezierCurveDefinition, AxisType gamepadAxisType) + { + this.AsString = bezierCurveDefinition; + return InitBezierCurve(mX1, mY1, mX2, mY2, gamepadAxisType); + } + + public bool InitBezierCurve(double x1, double y1, double x2, double y2, AxisType gamepadAxisType) + { + if (arrayBezierLUT == null) + arrayBezierLUT = new byte[256]; + + if (x1 < 0 || x1 > 1 || x2 < 0 || x2 > 1) + return false; + //throw new Exception("INVALID VALUE. BezierCurve X1 and X2 should be in [0, 1] range"); + + mX1 = x1; + mY1 = y1; + mX2 = x2; + mY2 = y2; + axisType = gamepadAxisType; + + // If this is linear definition then init the lookup table with 1-on-1 mapping + if(x1 == 0 && y1 == 0 && x2 == 0 && y2 == 0) + { + for (int idx = 0; idx <= 255; idx++) + arrayBezierLUT[idx] = (byte)idx; + + return true; + } + + try + { + double axisMaxDouble; + double axisCenterPosDouble; + + switch (gamepadAxisType) + { + case AxisType.LSRS: + axisMaxDouble = 127; // DS4 LS/RS axis has a "center position" at 128. Left turn has 0..127 positions and right turn 128..255 positions. + axisCenterPosDouble = 128; + break; + + case AxisType.L2R2: + axisMaxDouble = 255; // L2R2 analog trigger range 0..255 + axisCenterPosDouble = 0; + break; + + default: + axisMaxDouble = 128; // SixAxis x/z/y range 0..128 + axisCenterPosDouble = 0; + break; + } + + arraySampleValues = new double[BezierCurve.kSplineTableSize]; + for (int idx = 0; idx < BezierCurve.kSplineTableSize; idx++) + arraySampleValues[idx] = CalcBezier(idx * BezierCurve.kSampleStepSize, mX1, mX2); + + // Pre-populate lookup result table for GetBezierEasing function (performance optimization) + for (byte idx = 0; idx <= (byte)axisMaxDouble; idx++) + { + arrayBezierLUT[idx + (byte)axisCenterPosDouble] = (byte)(Global.Clamp(0, Math.Round(CalcBezier(getTForX(idx / axisMaxDouble), mY1, mY2) * axisMaxDouble), axisMaxDouble) + axisCenterPosDouble); + + // Invert curve from a right side of the center position (128) to the left tilted stick axis (or from up tilt to down tilt) + if (gamepadAxisType == AxisType.LSRS) + arrayBezierLUT[127 - idx] = (byte)(255 - arrayBezierLUT[idx + (byte)axisCenterPosDouble]); + + // If the axisMaxDouble is 255 then we need this to break the look (byte is unsigned 0..255, so the FOR loop never reaches 256 idx value. C# would throw an overflow exceptio) + if (idx == axisMaxDouble) break; + } + } + finally + { + arraySampleValues = null; + } + + return true; + } + + public byte GetBezierEasing(byte inputXValue) + { + unchecked + { + return (arrayBezierLUT == null ? inputXValue : arrayBezierLUT[inputXValue]); + //return (byte)(Global.Clamp(0, Math.Round(CalcBezier(getTForX(inputXValue / 255), mY1, mY2) * 255), 255)); + } + } + + private double A(double aA1, double aA2) { return 1.0 - 3.0 * aA2 + 3.0 * aA1; } + private double B(double aA1, double aA2) { return 3.0 * aA2 - 6.0 * aA1; } + private double C(double aA1) { return 3.0 * aA1; } + + private double CalcBezier(double aT, double aA1, double aA2) + { + return ((A(aA1, aA2) * aT + B(aA1, aA2)) * aT + C(aA1)) * aT; + } + + private double getTForX(double aX) + { + double intervalStart = 0.0; + int currentSample = 1; + int lastSample = kSplineTableSize - 1; + + for (; currentSample != lastSample && arraySampleValues[currentSample] <= aX; ++currentSample) + { + intervalStart += kSampleStepSize; + } + --currentSample; + + // Interpolate to provide an initial guess for t + double dist = (aX - arraySampleValues[currentSample]) / (arraySampleValues[currentSample + 1] - arraySampleValues[currentSample]); + double guessForT = intervalStart + dist * kSampleStepSize; + + double initialSlope = getSlope(guessForT, mX1, mX2); + if (initialSlope >= NEWTON_MIN_SLOPE) + { + return newtonRaphsonIterate(aX, guessForT /*, mX1, mX2*/); + } + else if (initialSlope == 0.0) + { + return guessForT; + } + else + { + return binarySubdivide(aX, intervalStart, intervalStart + kSampleStepSize /*, mX1, mX2*/); + } + } + + // Returns dx/dt given t, x1, and x2, or dy/dt given t, y1, and y2. + private double getSlope(double aT, double aA1, double aA2) + { + return 3.0 * A(aA1, aA2) * aT * aT + 2.0 * B(aA1, aA2) * aT + C(aA1); + } + + private double newtonRaphsonIterate(double aX, double aGuessT /*, double mX1, double mX2*/) + { + for (int i = 0; i < BezierCurve.NEWTON_ITERATIONS; ++i) + { + double currentSlope = getSlope(aGuessT, mX1, mX2); + if (currentSlope == 0.0) + { + return aGuessT; + } + double currentX = CalcBezier(aGuessT, mX1, mX2) - aX; + aGuessT -= currentX / currentSlope; + } + return aGuessT; + } + + private double binarySubdivide(double aX, double aA, double aB /*, double mX1, double mX2*/) + { + double currentX, currentT, i = 0; + do + { + currentT = aA + (aB - aA) / 2.0; + currentX = CalcBezier(currentT, mX1, mX2) - aX; + if (currentX > 0.0) + { + aB = currentT; + } + else + { + aA = currentT; + } + } while (Math.Abs(currentX) > BezierCurve.SUBDIVISION_PRECISION && ++i < BezierCurve.SUBDIVISION_MAX_ITERATIONS); + + return currentT; + } + + } +} diff --git a/DS4Windows/BezierCurveEditor/build.js b/DS4Windows/BezierCurveEditor/build.js new file mode 100644 index 0000000..278059d --- /dev/null +++ b/DS4Windows/BezierCurveEditor/build.js @@ -0,0 +1,10114 @@ +! function e(t, n, r) { + function o(i, s) { + if (!n[i]) { + if (!t[i]) { + var u = "function" == typeof require && require; + if (!s && u) return u(i, !0); + if (a) return a(i, !0); + var c = new Error("Cannot find module '" + i + "'"); + throw c.code = "MODULE_NOT_FOUND", c + } + var l = n[i] = { + exports: {} + }; + t[i][0].call(l.exports, function(e) { + var n = t[i][1][e]; + return o(n ? n : e) + }, l, l.exports, e, t, n, r) + } + return n[i].exports + } + for (var a = "function" == typeof require && require, i = 0; i < r.length; i++) o(r[i]); + return o +}({ + 1: [function(e) { + "use strict"; + var t = function(e) { + return e && e.__esModule ? e["default"] : e + }, + n = function() { + function e(e, t) { + for (var n in t) { + var r = t[n]; + r.configurable = !0, r.value && (r.writable = !0) + } + Object.defineProperties(e, t) + } + return function(t, n, r) { + return n && e(t.prototype, n), r && e(t, r), t + } + }(), + r = function f(e, t, n) { + var r = Object.getOwnPropertyDescriptor(e, t); + if (void 0 === r) { + var o = Object.getPrototypeOf(e); + return null === o ? void 0 : f(o, t, n) + } + if ("value" in r && r.writable) return r.value; + var a = r.get; + return void 0 === a ? void 0 : a.call(n) + }, + o = function(e, t) { + if ("function" != typeof t && null !== t) throw new TypeError("Super expression must either be null or a function, not " + typeof t); + e.prototype = Object.create(t && t.prototype, { + constructor: { + value: e, + enumerable: !1, + writable: !0, + configurable: !0 + } + }), t && (e.__proto__ = t) + }, + a = function(e, t) { + if (!(e instanceof t)) throw new TypeError("Cannot call a class as a function") + }, + i = t(e("react/addons")), + s = t(e("..")), + u = t(e("../package.json")), + c = t(e("raf")); + window.Perf = i.addons.Perf; + var l = { + color: "#0000c6", + textDecoration: "none" + }, + p = { + display: "inline-block", + margin: "5px" + }, + qryVariableValue = function(variableName) + { + var query = window.location.search.substring(1); + var vars = query.split("&"); + for (var i=0;i o; ++o) { + var a = v(r, e, c); + if (0 === a) return r; + var i = h(r, e, c) - t; + r -= i / a + } + return r + } + + function y() { + for (var t = 0; i > t; ++t) _[t] = h(t * s, e, c) + } + + function g(t, n, r) { + var i, s, u = 0; + do s = n + (r - n) / 2, i = h(s, e, c) - t, i > 0 ? r = s : n = s; while (Math.abs(i) > o && ++u < a); + return s + } + + function E(t) { + for (var n = 0, o = 1, a = i - 1; o != a && _[o] <= t; ++o) n += s; + --o; + var u = (t - _[o]) / (_[o + 1] - _[o]), + l = n + u * s, + p = v(l, e, c); + return p >= r ? m(t, l) : 0 === p ? l : g(t, n, n + s) + } + + function C() { + N = !0, (e != t || c != l) && y() + } + if (4 !== arguments.length) throw new Error("BezierEasing requires 4 arguments."); + for (var b = 0; 4 > b; ++b) + if ("number" != typeof arguments[b] || isNaN(arguments[b]) || !isFinite(arguments[b])) throw new Error("BezierEasing arguments should be integers."); + if (0 > e || e > 1 || 0 > c || c > 1) throw new Error("BezierEasing x values must be in [0, 1] range."); + var _ = u ? new Float32Array(i) : new Array(i), + N = !1, + O = function(n) { + return N || C(), e === t && c === l ? n : 0 === n ? 0 : 1 === n ? 1 : h(E(n), t, l) + }; + O.getControlPoints = function() { + return [{ + x: e, + y: t + }, { + x: c, + y: l + }] + }; + var R = [e, t, c, l], + D = "BezierEasing(" + R + ")"; + O.toString = function() { + return D + }; + var w = "cubic-bezier(" + R + ")"; + return O.toCSS = function() { + return w + }, O + } + var t = this, + n = 4, + r = .001, + o = 1e-7, + a = 10, + i = 11, + s = 1 / (i - 1), + u = "Float32Array" in t; + return e.css = { + ease: e(.25, .1, .25, 1), + linear: e(0, 0, 1, 1), + "ease-in": e(.42, 0, 1, 1), + "ease-out": e(0, 0, .58, 1), + "ease-in-out": e(.42, 0, .58, 1) + }, e + }) + }, {}], + 6: [function(e, t) { + "use strict"; + + function n(e) { + if (null == e) throw new TypeError("Object.assign cannot be called with null or undefined"); + return Object(e) + } + t.exports = Object.assign || function(e) { + for (var t, r, o = n(e), a = 1; a < arguments.length; a++) { + t = arguments[a], r = Object.keys(Object(t)); + for (var i = 0; i < r.length; i++) o[r[i]] = t[r[i]] + } + return o + } + }, {}], + 7: [function(e, t) { + t.exports = e("./lib/ReactWithAddons") + }, { + "./lib/ReactWithAddons": 107 + }], + 8: [function(e, t) { + "use strict"; + var n = e("./focusNode"), + r = { + componentDidMount: function() { + this.props.autoFocus && n(this.getDOMNode()) + } + }; + t.exports = r + }, { + "./focusNode": 141 + }], + 9: [function(e, t) { + "use strict"; + + function n() { + var e = window.opera; + return "object" == typeof e && "function" == typeof e.version && parseInt(e.version(), 10) <= 12 + } + + function r(e) { + return (e.ctrlKey || e.altKey || e.metaKey) && !(e.ctrlKey && e.altKey) + } + + function o(e) { + switch (e) { + case w.topCompositionStart: + return M.compositionStart; + case w.topCompositionEnd: + return M.compositionEnd; + case w.topCompositionUpdate: + return M.compositionUpdate + } + } + + function a(e, t) { + return e === w.topKeyDown && t.keyCode === C + } + + function i(e, t) { + switch (e) { + case w.topKeyUp: + return -1 !== E.indexOf(t.keyCode); + case w.topKeyDown: + return t.keyCode !== C; + case w.topKeyPress: + case w.topMouseDown: + case w.topBlur: + return !0; + default: + return !1 + } + } + + function s(e) { + var t = e.detail; + return "object" == typeof t && "data" in t ? t.data : null + } + + function u(e, t, n, r) { + var u, c; + if (b ? u = o(e) : T ? i(e, r) && (u = M.compositionEnd) : a(e, r) && (u = M.compositionStart), !u) return null; + O && (T || u !== M.compositionStart ? u === M.compositionEnd && T && (c = T.getData()) : T = v.getPooled(t)); + var l = m.getPooled(u, n, r); + if (c) l.data = c; + else { + var p = s(r); + null !== p && (l.data = p) + } + return f.accumulateTwoPhaseDispatches(l), l + } + + function c(e, t) { + switch (e) { + case w.topCompositionEnd: + return s(t); + case w.topKeyPress: + var n = t.which; + return n !== R ? null : (x = !0, D); + case w.topTextInput: + var r = t.data; + return r === D && x ? null : r; + default: + return null + } + } + + function l(e, t) { + if (T) { + if (e === w.topCompositionEnd || i(e, t)) { + var n = T.getData(); + return v.release(T), T = null, n + } + return null + } + switch (e) { + case w.topPaste: + return null; + case w.topKeyPress: + return t.which && !r(t) ? String.fromCharCode(t.which) : null; + case w.topCompositionEnd: + return O ? null : t.data; + default: + return null + } + } + + function p(e, t, n, r) { + var o; + if (o = N ? c(e, r) : l(e, r), !o) return null; + var a = y.getPooled(M.beforeInput, n, r); + return a.data = o, f.accumulateTwoPhaseDispatches(a), a + } + var d = e("./EventConstants"), + f = e("./EventPropagators"), + h = e("./ExecutionEnvironment"), + v = e("./FallbackCompositionState"), + m = e("./SyntheticCompositionEvent"), + y = e("./SyntheticInputEvent"), + g = e("./keyOf"), + E = [9, 13, 27, 32], + C = 229, + b = h.canUseDOM && "CompositionEvent" in window, + _ = null; + h.canUseDOM && "documentMode" in document && (_ = document.documentMode); + var N = h.canUseDOM && "TextEvent" in window && !_ && !n(), + O = h.canUseDOM && (!b || _ && _ > 8 && 11 >= _), + R = 32, + D = String.fromCharCode(R), + w = d.topLevelTypes, + M = { + beforeInput: { + phasedRegistrationNames: { + bubbled: g({ + onBeforeInput: null + }), + captured: g({ + onBeforeInputCapture: null + }) + }, + dependencies: [w.topCompositionEnd, w.topKeyPress, w.topTextInput, w.topPaste] + }, + compositionEnd: { + phasedRegistrationNames: { + bubbled: g({ + onCompositionEnd: null + }), + captured: g({ + onCompositionEndCapture: null + }) + }, + dependencies: [w.topBlur, w.topCompositionEnd, w.topKeyDown, w.topKeyPress, w.topKeyUp, w.topMouseDown] + }, + compositionStart: { + phasedRegistrationNames: { + bubbled: g({ + onCompositionStart: null + }), + captured: g({ + onCompositionStartCapture: null + }) + }, + dependencies: [w.topBlur, w.topCompositionStart, w.topKeyDown, w.topKeyPress, w.topKeyUp, w.topMouseDown] + }, + compositionUpdate: { + phasedRegistrationNames: { + bubbled: g({ + onCompositionUpdate: null + }), + captured: g({ + onCompositionUpdateCapture: null + }) + }, + dependencies: [w.topBlur, w.topCompositionUpdate, w.topKeyDown, w.topKeyPress, w.topKeyUp, w.topMouseDown] + } + }, + x = !1, + T = null, + P = { + eventTypes: M, + extractEvents: function(e, t, n, r) { + return [u(e, t, n, r), p(e, t, n, r)] + } + }; + t.exports = P + }, { + "./EventConstants": 22, + "./EventPropagators": 27, + "./ExecutionEnvironment": 28, + "./FallbackCompositionState": 29, + "./SyntheticCompositionEvent": 113, + "./SyntheticInputEvent": 117, + "./keyOf": 164 + }], + 10: [function(e, t) { + (function(n) { + var r = e("./invariant"), + o = { + addClass: function(e, t) { + return "production" !== n.env.NODE_ENV ? r(!/\s/.test(t), 'CSSCore.addClass takes only a single class name. "%s" contains multiple classes.', t) : r(!/\s/.test(t)), t && (e.classList ? e.classList.add(t) : o.hasClass(e, t) || (e.className = e.className + " " + t)), e + }, + removeClass: function(e, t) { + return "production" !== n.env.NODE_ENV ? r(!/\s/.test(t), 'CSSCore.removeClass takes only a single class name. "%s" contains multiple classes.', t) : r(!/\s/.test(t)), t && (e.classList ? e.classList.remove(t) : o.hasClass(e, t) && (e.className = e.className.replace(new RegExp("(^|\\s)" + t + "(?:\\s|$)", "g"), "$1").replace(/\s+/g, " ").replace(/^\s*|\s*$/g, ""))), e + }, + conditionClass: function(e, t, n) { + return (n ? o.addClass : o.removeClass)(e, t) + }, + hasClass: function(e, t) { + return "production" !== n.env.NODE_ENV ? r(!/\s/.test(t), "CSS.hasClass takes only a single class name.") : r(!/\s/.test(t)), e.classList ? !!t && e.classList.contains(t) : (" " + e.className + " ").indexOf(" " + t + " ") > -1 + } + }; + t.exports = o + }).call(this, e("_process")) + }, { + "./invariant": 157, + _process: 2 + }], + 11: [function(e, t) { + "use strict"; + + function n(e, t) { + return e + t.charAt(0).toUpperCase() + t.substring(1) + } + var r = { + boxFlex: !0, + boxFlexGroup: !0, + columnCount: !0, + flex: !0, + flexGrow: !0, + flexShrink: !0, + fontWeight: !0, + lineClamp: !0, + lineHeight: !0, + opacity: !0, + order: !0, + orphans: !0, + widows: !0, + zIndex: !0, + zoom: !0, + fillOpacity: !0, + strokeOpacity: !0 + }, + o = ["Webkit", "ms", "Moz", "O"]; + Object.keys(r).forEach(function(e) { + o.forEach(function(t) { + r[n(t, e)] = r[e] + }) + }); + var a = { + background: { + backgroundImage: !0, + backgroundPosition: !0, + backgroundRepeat: !0, + backgroundColor: !0 + }, + border: { + borderWidth: !0, + borderStyle: !0, + borderColor: !0 + }, + borderBottom: { + borderBottomWidth: !0, + borderBottomStyle: !0, + borderBottomColor: !0 + }, + borderLeft: { + borderLeftWidth: !0, + borderLeftStyle: !0, + borderLeftColor: !0 + }, + borderRight: { + borderRightWidth: !0, + borderRightStyle: !0, + borderRightColor: !0 + }, + borderTop: { + borderTopWidth: !0, + borderTopStyle: !0, + borderTopColor: !0 + }, + font: { + fontStyle: !0, + fontVariant: !0, + fontWeight: !0, + fontSize: !0, + lineHeight: !0, + fontFamily: !0 + } + }, + i = { + isUnitlessNumber: r, + shorthandPropertyExpansions: a + }; + t.exports = i + }, {}], + 12: [function(e, t) { + (function(n) { + "use strict"; + var r = e("./CSSProperty"), + o = e("./ExecutionEnvironment"), + a = e("./camelizeStyleName"), + i = e("./dangerousStyleValue"), + s = e("./hyphenateStyleName"), + u = e("./memoizeStringOnly"), + c = e("./warning"), + l = u(function(e) { + return s(e) + }), + p = "cssFloat"; + if (o.canUseDOM && void 0 === document.documentElement.style.cssFloat && (p = "styleFloat"), "production" !== n.env.NODE_ENV) var d = /^(?:webkit|moz|o)[A-Z]/, + f = /;\s*$/, + h = {}, + v = {}, + m = function(e) { + h.hasOwnProperty(e) && h[e] || (h[e] = !0, "production" !== n.env.NODE_ENV ? c(!1, "Unsupported style property %s. Did you mean %s?", e, a(e)) : null) + }, + y = function(e) { + h.hasOwnProperty(e) && h[e] || (h[e] = !0, "production" !== n.env.NODE_ENV ? c(!1, "Unsupported vendor-prefixed style property %s. Did you mean %s?", e, e.charAt(0).toUpperCase() + e.slice(1)) : null) + }, + g = function(e, t) { + v.hasOwnProperty(t) && v[t] || (v[t] = !0, "production" !== n.env.NODE_ENV ? c(!1, 'Style property values shouldn\'t contain a semicolon. Try "%s: %s" instead.', e, t.replace(f, "")) : null) + }, + E = function(e, t) { + e.indexOf("-") > -1 ? m(e) : d.test(e) ? y(e) : f.test(t) && g(e, t) + }; + var C = { + createMarkupForStyles: function(e) { + var t = ""; + for (var r in e) + if (e.hasOwnProperty(r)) { + var o = e[r]; + "production" !== n.env.NODE_ENV && E(r, o), null != o && (t += l(r) + ":", t += i(r, o) + ";") + } return t || null + }, + setValueForStyles: function(e, t) { + var o = e.style; + for (var a in t) + if (t.hasOwnProperty(a)) { + "production" !== n.env.NODE_ENV && E(a, t[a]); + var s = i(a, t[a]); + if ("float" === a && (a = p), s) o[a] = s; + else { + var u = r.shorthandPropertyExpansions[a]; + if (u) + for (var c in u) o[c] = ""; + else o[a] = "" + } + } + } + }; + t.exports = C + }).call(this, e("_process")) + }, { + "./CSSProperty": 11, + "./ExecutionEnvironment": 28, + "./camelizeStyleName": 128, + "./dangerousStyleValue": 135, + "./hyphenateStyleName": 155, + "./memoizeStringOnly": 166, + "./warning": 178, + _process: 2 + }], + 13: [function(e, t) { + (function(n) { + "use strict"; + + function r() { + this._callbacks = null, this._contexts = null + } + var o = e("./PooledClass"), + a = e("./Object.assign"), + i = e("./invariant"); + a(r.prototype, { + enqueue: function(e, t) { + this._callbacks = this._callbacks || [], this._contexts = this._contexts || [], this._callbacks.push(e), this._contexts.push(t) + }, + notifyAll: function() { + var e = this._callbacks, + t = this._contexts; + if (e) { + "production" !== n.env.NODE_ENV ? i(e.length === t.length, "Mismatched list of contexts in callback queue") : i(e.length === t.length), this._callbacks = null, this._contexts = null; + for (var r = 0, o = e.length; o > r; r++) e[r].call(t[r]); + e.length = 0, t.length = 0 + } + }, + reset: function() { + this._callbacks = null, this._contexts = null + }, + destructor: function() { + this.reset() + } + }), o.addPoolingTo(r), t.exports = r + }).call(this, e("_process")) + }, { + "./Object.assign": 35, + "./PooledClass": 36, + "./invariant": 157, + _process: 2 + }], + 14: [function(e, t) { + "use strict"; + + function n(e) { + return "SELECT" === e.nodeName || "INPUT" === e.nodeName && "file" === e.type + } + + function r(e) { + var t = _.getPooled(w.change, x, e); + E.accumulateTwoPhaseDispatches(t), b.batchedUpdates(o, t) + } + + function o(e) { + g.enqueueEvents(e), g.processEventQueue() + } + + function a(e, t) { + M = e, x = t, M.attachEvent("onchange", r) + } + + function i() { + M && (M.detachEvent("onchange", r), M = null, x = null) + } + + function s(e, t, n) { + return e === D.topChange ? n : void 0 + } + + function u(e, t, n) { + e === D.topFocus ? (i(), a(t, n)) : e === D.topBlur && i() + } + + function c(e, t) { + M = e, x = t, T = e.value, P = Object.getOwnPropertyDescriptor(e.constructor.prototype, "value"), Object.defineProperty(M, "value", k), M.attachEvent("onpropertychange", p) + } + + function l() { + M && (delete M.value, M.detachEvent("onpropertychange", p), M = null, x = null, T = null, P = null) + } + + function p(e) { + if ("value" === e.propertyName) { + var t = e.srcElement.value; + t !== T && (T = t, r(e)) + } + } + + function d(e, t, n) { + return e === D.topInput ? n : void 0 + } + + function f(e, t, n) { + e === D.topFocus ? (l(), c(t, n)) : e === D.topBlur && l() + } + + function h(e) { + return e !== D.topSelectionChange && e !== D.topKeyUp && e !== D.topKeyDown || !M || M.value === T ? void 0 : (T = M.value, x) + } + + function v(e) { + return "INPUT" === e.nodeName && ("checkbox" === e.type || "radio" === e.type) + } + + function m(e, t, n) { + return e === D.topClick ? n : void 0 + } + var y = e("./EventConstants"), + g = e("./EventPluginHub"), + E = e("./EventPropagators"), + C = e("./ExecutionEnvironment"), + b = e("./ReactUpdates"), + _ = e("./SyntheticEvent"), + N = e("./isEventSupported"), + O = e("./isTextInputElement"), + R = e("./keyOf"), + D = y.topLevelTypes, + w = { + change: { + phasedRegistrationNames: { + bubbled: R({ + onChange: null + }), + captured: R({ + onChangeCapture: null + }) + }, + dependencies: [D.topBlur, D.topChange, D.topClick, D.topFocus, D.topInput, D.topKeyDown, D.topKeyUp, D.topSelectionChange] + } + }, + M = null, + x = null, + T = null, + P = null, + I = !1; + C.canUseDOM && (I = N("change") && (!("documentMode" in document) || document.documentMode > 8)); + var S = !1; + C.canUseDOM && (S = N("input") && (!("documentMode" in document) || document.documentMode > 9)); + var k = { + get: function() { + return P.get.call(this) + }, + set: function(e) { + T = "" + e, P.set.call(this, e) + } + }, + A = { + eventTypes: w, + extractEvents: function(e, t, r, o) { + var a, i; + if (n(t) ? I ? a = s : i = u : O(t) ? S ? a = d : (a = h, i = f) : v(t) && (a = m), a) { + var c = a(e, t, r); + if (c) { + var l = _.getPooled(w.change, c, o); + return E.accumulateTwoPhaseDispatches(l), l + } + } + i && i(e, t, r) + } + }; + t.exports = A + }, { + "./EventConstants": 22, + "./EventPluginHub": 24, + "./EventPropagators": 27, + "./ExecutionEnvironment": 28, + "./ReactUpdates": 106, + "./SyntheticEvent": 115, + "./isEventSupported": 158, + "./isTextInputElement": 160, + "./keyOf": 164 + }], + 15: [function(e, t) { + "use strict"; + var n = 0, + r = { + createReactRootIndex: function() { + return n++ + } + }; + t.exports = r + }, {}], + 16: [function(e, t) { + (function(n) { + "use strict"; + + function r(e, t, n) { + e.insertBefore(t, e.childNodes[n] || null) + } + var o = e("./Danger"), + a = e("./ReactMultiChildUpdateTypes"), + i = e("./setTextContent"), + s = e("./invariant"), + u = { + dangerouslyReplaceNodeWithMarkup: o.dangerouslyReplaceNodeWithMarkup, + updateTextContent: i, + processUpdates: function(e, t) { + for (var u, c = null, l = null, p = 0; p < e.length; p++) + if (u = e[p], u.type === a.MOVE_EXISTING || u.type === a.REMOVE_NODE) { + var d = u.fromIndex, + f = u.parentNode.childNodes[d], + h = u.parentID; + "production" !== n.env.NODE_ENV ? s(f, "processUpdates(): Unable to find child %s of element. This probably means the DOM was unexpectedly mutated (e.g., by the browser), usually due to forgetting a when using tables, nesting tags like
,

, or , or using non-SVG elements in an parent. Try inspecting the child nodes of the element with React ID `%s`.", d, h) : s(f), c = c || {}, c[h] = c[h] || [], c[h][d] = f, l = l || [], l.push(f) + } var v = o.dangerouslyRenderMarkup(t); + if (l) + for (var m = 0; m < l.length; m++) l[m].parentNode.removeChild(l[m]); + for (var y = 0; y < e.length; y++) switch (u = e[y], u.type) { + case a.INSERT_MARKUP: + r(u.parentNode, v[u.markupIndex], u.toIndex); + break; + case a.MOVE_EXISTING: + r(u.parentNode, c[u.parentID][u.fromIndex], u.toIndex); + break; + case a.TEXT_CONTENT: + i(u.parentNode, u.textContent); + break; + case a.REMOVE_NODE: + } + } + }; + t.exports = u + }).call(this, e("_process")) + }, { + "./Danger": 19, + "./ReactMultiChildUpdateTypes": 85, + "./invariant": 157, + "./setTextContent": 172, + _process: 2 + }], + 17: [function(e, t) { + (function(n) { + "use strict"; + + function r(e, t) { + return (e & t) === t + } + var o = e("./invariant"), + a = { + MUST_USE_ATTRIBUTE: 1, + MUST_USE_PROPERTY: 2, + HAS_SIDE_EFFECTS: 4, + HAS_BOOLEAN_VALUE: 8, + HAS_NUMERIC_VALUE: 16, + HAS_POSITIVE_NUMERIC_VALUE: 48, + HAS_OVERLOADED_BOOLEAN_VALUE: 64, + injectDOMPropertyConfig: function(e) { + var t = e.Properties || {}, + i = e.DOMAttributeNames || {}, + u = e.DOMPropertyNames || {}, + c = e.DOMMutationMethods || {}; + e.isCustomAttribute && s._isCustomAttributeFunctions.push(e.isCustomAttribute); + for (var l in t) { + "production" !== n.env.NODE_ENV ? o(!s.isStandardName.hasOwnProperty(l), "injectDOMPropertyConfig(...): You're trying to inject DOM property '%s' which has already been injected. You may be accidentally injecting the same DOM property config twice, or you may be injecting two configs that have conflicting property names.", l) : o(!s.isStandardName.hasOwnProperty(l)), s.isStandardName[l] = !0; + var p = l.toLowerCase(); + if (s.getPossibleStandardName[p] = l, i.hasOwnProperty(l)) { + var d = i[l]; + s.getPossibleStandardName[d] = l, s.getAttributeName[l] = d + } else s.getAttributeName[l] = p; + s.getPropertyName[l] = u.hasOwnProperty(l) ? u[l] : l, s.getMutationMethod[l] = c.hasOwnProperty(l) ? c[l] : null; + var f = t[l]; + s.mustUseAttribute[l] = r(f, a.MUST_USE_ATTRIBUTE), s.mustUseProperty[l] = r(f, a.MUST_USE_PROPERTY), s.hasSideEffects[l] = r(f, a.HAS_SIDE_EFFECTS), s.hasBooleanValue[l] = r(f, a.HAS_BOOLEAN_VALUE), s.hasNumericValue[l] = r(f, a.HAS_NUMERIC_VALUE), s.hasPositiveNumericValue[l] = r(f, a.HAS_POSITIVE_NUMERIC_VALUE), s.hasOverloadedBooleanValue[l] = r(f, a.HAS_OVERLOADED_BOOLEAN_VALUE), "production" !== n.env.NODE_ENV ? o(!s.mustUseAttribute[l] || !s.mustUseProperty[l], "DOMProperty: Cannot require using both attribute and property: %s", l) : o(!s.mustUseAttribute[l] || !s.mustUseProperty[l]), "production" !== n.env.NODE_ENV ? o(s.mustUseProperty[l] || !s.hasSideEffects[l], "DOMProperty: Properties that have side effects must use property: %s", l) : o(s.mustUseProperty[l] || !s.hasSideEffects[l]), "production" !== n.env.NODE_ENV ? o(!!s.hasBooleanValue[l] + !!s.hasNumericValue[l] + !!s.hasOverloadedBooleanValue[l] <= 1, "DOMProperty: Value can be one of boolean, overloaded boolean, or numeric value, but not a combination: %s", l) : o(!!s.hasBooleanValue[l] + !!s.hasNumericValue[l] + !!s.hasOverloadedBooleanValue[l] <= 1) + } + } + }, + i = {}, + s = { + ID_ATTRIBUTE_NAME: "data-reactid", + isStandardName: {}, + getPossibleStandardName: {}, + getAttributeName: {}, + getPropertyName: {}, + getMutationMethod: {}, + mustUseAttribute: {}, + mustUseProperty: {}, + hasSideEffects: {}, + hasBooleanValue: {}, + hasNumericValue: {}, + hasPositiveNumericValue: {}, + hasOverloadedBooleanValue: {}, + _isCustomAttributeFunctions: [], + isCustomAttribute: function(e) { + for (var t = 0; t < s._isCustomAttributeFunctions.length; t++) { + var n = s._isCustomAttributeFunctions[t]; + if (n(e)) return !0 + } + return !1 + }, + getDefaultValueForProperty: function(e, t) { + var n, r = i[e]; + return r || (i[e] = r = {}), t in r || (n = document.createElement(e), r[t] = n[t]), r[t] + }, + injection: a + }; + t.exports = s + }).call(this, e("_process")) + }, { + "./invariant": 157, + _process: 2 + }], + 18: [function(e, t) { + (function(n) { + "use strict"; + + function r(e, t) { + return null == t || o.hasBooleanValue[e] && !t || o.hasNumericValue[e] && isNaN(t) || o.hasPositiveNumericValue[e] && 1 > t || o.hasOverloadedBooleanValue[e] && t === !1 + } + var o = e("./DOMProperty"), + a = e("./quoteAttributeValueForBrowser"), + i = e("./warning"); + if ("production" !== n.env.NODE_ENV) var s = { + children: !0, + dangerouslySetInnerHTML: !0, + key: !0, + ref: !0 + }, + u = {}, + c = function(e) { + if (!(s.hasOwnProperty(e) && s[e] || u.hasOwnProperty(e) && u[e])) { + u[e] = !0; + var t = e.toLowerCase(), + r = o.isCustomAttribute(t) ? t : o.getPossibleStandardName.hasOwnProperty(t) ? o.getPossibleStandardName[t] : null; + "production" !== n.env.NODE_ENV ? i(null == r, "Unknown DOM property %s. Did you mean %s?", e, r) : null + } + }; + var l = { + createMarkupForID: function(e) { + return o.ID_ATTRIBUTE_NAME + "=" + a(e) + }, + createMarkupForProperty: function(e, t) { + if (o.isStandardName.hasOwnProperty(e) && o.isStandardName[e]) { + if (r(e, t)) return ""; + var i = o.getAttributeName[e]; + return o.hasBooleanValue[e] || o.hasOverloadedBooleanValue[e] && t === !0 ? i : i + "=" + a(t) + } + return o.isCustomAttribute(e) ? null == t ? "" : e + "=" + a(t) : ("production" !== n.env.NODE_ENV && c(e), null) + }, + setValueForProperty: function(e, t, a) { + if (o.isStandardName.hasOwnProperty(t) && o.isStandardName[t]) { + var i = o.getMutationMethod[t]; + if (i) i(e, a); + else if (r(t, a)) this.deleteValueForProperty(e, t); + else if (o.mustUseAttribute[t]) e.setAttribute(o.getAttributeName[t], "" + a); + else { + var s = o.getPropertyName[t]; + o.hasSideEffects[t] && "" + e[s] == "" + a || (e[s] = a) + } + } else o.isCustomAttribute(t) ? null == a ? e.removeAttribute(t) : e.setAttribute(t, "" + a) : "production" !== n.env.NODE_ENV && c(t) + }, + deleteValueForProperty: function(e, t) { + if (o.isStandardName.hasOwnProperty(t) && o.isStandardName[t]) { + var r = o.getMutationMethod[t]; + if (r) r(e, void 0); + else if (o.mustUseAttribute[t]) e.removeAttribute(o.getAttributeName[t]); + else { + var a = o.getPropertyName[t], + i = o.getDefaultValueForProperty(e.nodeName, a); + o.hasSideEffects[t] && "" + e[a] === i || (e[a] = i) + } + } else o.isCustomAttribute(t) ? e.removeAttribute(t) : "production" !== n.env.NODE_ENV && c(t) + } + }; + t.exports = l + }).call(this, e("_process")) + }, { + "./DOMProperty": 17, + "./quoteAttributeValueForBrowser": 170, + "./warning": 178, + _process: 2 + }], + 19: [function(e, t) { + (function(n) { + "use strict"; + + function r(e) { + return e.substring(1, e.indexOf(" ")) + } + var o = e("./ExecutionEnvironment"), + a = e("./createNodesFromMarkup"), + i = e("./emptyFunction"), + s = e("./getMarkupWrap"), + u = e("./invariant"), + c = /^(<[^ \/>]+)/, + l = "data-danger-index", + p = { + dangerouslyRenderMarkup: function(e) { + "production" !== n.env.NODE_ENV ? u(o.canUseDOM, "dangerouslyRenderMarkup(...): Cannot render markup in a worker thread. Make sure `window` and `document` are available globally before requiring React when unit testing or use React.renderToString for server rendering.") : u(o.canUseDOM); + for (var t, p = {}, d = 0; d < e.length; d++) "production" !== n.env.NODE_ENV ? u(e[d], "dangerouslyRenderMarkup(...): Missing markup.") : u(e[d]), t = r(e[d]), t = s(t) ? t : "*", p[t] = p[t] || [], p[t][d] = e[d]; + var f = [], + h = 0; + for (t in p) + if (p.hasOwnProperty(t)) { + var v, m = p[t]; + for (v in m) + if (m.hasOwnProperty(v)) { + var y = m[v]; + m[v] = y.replace(c, "$1 " + l + '="' + v + '" ') + } for (var g = a(m.join(""), i), E = 0; E < g.length; ++E) { + var C = g[E]; + C.hasAttribute && C.hasAttribute(l) ? (v = +C.getAttribute(l), C.removeAttribute(l), "production" !== n.env.NODE_ENV ? u(!f.hasOwnProperty(v), "Danger: Assigning to an already-occupied result index.") : u(!f.hasOwnProperty(v)), f[v] = C, h += 1) : "production" !== n.env.NODE_ENV && console.error("Danger: Discarding unexpected node:", C) + } + } return "production" !== n.env.NODE_ENV ? u(h === f.length, "Danger: Did not assign to every index of resultList.") : u(h === f.length), "production" !== n.env.NODE_ENV ? u(f.length === e.length, "Danger: Expected markup to render %s nodes, but rendered %s.", e.length, f.length) : u(f.length === e.length), f + }, + dangerouslyReplaceNodeWithMarkup: function(e, t) { + "production" !== n.env.NODE_ENV ? u(o.canUseDOM, "dangerouslyReplaceNodeWithMarkup(...): Cannot render markup in a worker thread. Make sure `window` and `document` are available globally before requiring React when unit testing or use React.renderToString for server rendering.") : u(o.canUseDOM), "production" !== n.env.NODE_ENV ? u(t, "dangerouslyReplaceNodeWithMarkup(...): Missing markup.") : u(t), "production" !== n.env.NODE_ENV ? u("html" !== e.tagName.toLowerCase(), "dangerouslyReplaceNodeWithMarkup(...): Cannot replace markup of the node. This is because browser quirks make this unreliable and/or slow. If you want to render to the root you must use server rendering. See React.renderToString().") : u("html" !== e.tagName.toLowerCase()); + var r = a(t, i)[0]; + e.parentNode.replaceChild(r, e) + } + }; + t.exports = p + }).call(this, e("_process")) + }, { + "./ExecutionEnvironment": 28, + "./createNodesFromMarkup": 133, + "./emptyFunction": 136, + "./getMarkupWrap": 149, + "./invariant": 157, + _process: 2 + }], + 20: [function(e, t) { + "use strict"; + var n = e("./keyOf"), + r = [n({ + ResponderEventPlugin: null + }), n({ + SimpleEventPlugin: null + }), n({ + TapEventPlugin: null + }), n({ + EnterLeaveEventPlugin: null + }), n({ + ChangeEventPlugin: null + }), n({ + SelectEventPlugin: null + }), n({ + BeforeInputEventPlugin: null + }), n({ + AnalyticsEventPlugin: null + }), n({ + MobileSafariClickEventPlugin: null + })]; + t.exports = r + }, { + "./keyOf": 164 + }], + 21: [function(e, t) { + "use strict"; + var n = e("./EventConstants"), + r = e("./EventPropagators"), + o = e("./SyntheticMouseEvent"), + a = e("./ReactMount"), + i = e("./keyOf"), + s = n.topLevelTypes, + u = a.getFirstReactDOM, + c = { + mouseEnter: { + registrationName: i({ + onMouseEnter: null + }), + dependencies: [s.topMouseOut, s.topMouseOver] + }, + mouseLeave: { + registrationName: i({ + onMouseLeave: null + }), + dependencies: [s.topMouseOut, s.topMouseOver] + } + }, + l = [null, null], + p = { + eventTypes: c, + extractEvents: function(e, t, n, i) { + if (e === s.topMouseOver && (i.relatedTarget || i.fromElement)) return null; + if (e !== s.topMouseOut && e !== s.topMouseOver) return null; + var p; + if (t.window === t) p = t; + else { + var d = t.ownerDocument; + p = d ? d.defaultView || d.parentWindow : window + } + var f, h; + if (e === s.topMouseOut ? (f = t, h = u(i.relatedTarget || i.toElement) || p) : (f = p, h = t), f === h) return null; + var v = f ? a.getID(f) : "", + m = h ? a.getID(h) : "", + y = o.getPooled(c.mouseLeave, v, i); + y.type = "mouseleave", y.target = f, y.relatedTarget = h; + var g = o.getPooled(c.mouseEnter, m, i); + return g.type = "mouseenter", g.target = h, g.relatedTarget = f, r.accumulateEnterLeaveDispatches(y, g, v, m), l[0] = y, l[1] = g, l + } + }; + t.exports = p + }, { + "./EventConstants": 22, + "./EventPropagators": 27, + "./ReactMount": 83, + "./SyntheticMouseEvent": 119, + "./keyOf": 164 + }], + 22: [function(e, t) { + "use strict"; + var n = e("./keyMirror"), + r = n({ + bubbled: null, + captured: null + }), + o = n({ + topBlur: null, + topChange: null, + topClick: null, + topCompositionEnd: null, + topCompositionStart: null, + topCompositionUpdate: null, + topContextMenu: null, + topCopy: null, + topCut: null, + topDoubleClick: null, + topDrag: null, + topDragEnd: null, + topDragEnter: null, + topDragExit: null, + topDragLeave: null, + topDragOver: null, + topDragStart: null, + topDrop: null, + topError: null, + topFocus: null, + topInput: null, + topKeyDown: null, + topKeyPress: null, + topKeyUp: null, + topLoad: null, + topMouseDown: null, + topMouseMove: null, + topMouseOut: null, + topMouseOver: null, + topMouseUp: null, + topPaste: null, + topReset: null, + topScroll: null, + topSelectionChange: null, + topSubmit: null, + topTextInput: null, + topTouchCancel: null, + topTouchEnd: null, + topTouchMove: null, + topTouchStart: null, + topWheel: null + }), + a = { + topLevelTypes: o, + PropagationPhases: r + }; + t.exports = a + }, { + "./keyMirror": 163 + }], + 23: [function(e, t) { + (function(n) { + var r = e("./emptyFunction"), + o = { + listen: function(e, t, n) { + return e.addEventListener ? (e.addEventListener(t, n, !1), { + remove: function() { + e.removeEventListener(t, n, !1) + } + }) : e.attachEvent ? (e.attachEvent("on" + t, n), { + remove: function() { + e.detachEvent("on" + t, n) + } + }) : void 0 + }, + capture: function(e, t, o) { + return e.addEventListener ? (e.addEventListener(t, o, !0), { + remove: function() { + e.removeEventListener(t, o, !0) + } + }) : ("production" !== n.env.NODE_ENV && console.error("Attempted to listen to events during the capture phase on a browser that does not support the capture phase. Your application will not receive some events."), { + remove: r + }) + }, + registerDefault: function() {} + }; + t.exports = o + }).call(this, e("_process")) + }, { + "./emptyFunction": 136, + _process: 2 + }], + 24: [function(e, t) { + (function(n) { + "use strict"; + + function r() { + var e = d && d.traverseTwoPhase && d.traverseEnterLeave; + "production" !== n.env.NODE_ENV ? u(e, "InstanceHandle not injected before use!") : u(e) + } + var o = e("./EventPluginRegistry"), + a = e("./EventPluginUtils"), + i = e("./accumulateInto"), + s = e("./forEachAccumulated"), + u = e("./invariant"), + c = {}, + l = null, + p = function(e) { + if (e) { + var t = a.executeDispatch, + n = o.getPluginModuleForEvent(e); + n && n.executeDispatch && (t = n.executeDispatch), a.executeDispatchesInOrder(e, t), e.isPersistent() || e.constructor.release(e) + } + }, + d = null, + f = { + injection: { + injectMount: a.injection.injectMount, + injectInstanceHandle: function(e) { + d = e, "production" !== n.env.NODE_ENV && r() + }, + getInstanceHandle: function() { + return "production" !== n.env.NODE_ENV && r(), d + }, + injectEventPluginOrder: o.injectEventPluginOrder, + injectEventPluginsByName: o.injectEventPluginsByName + }, + eventNameDispatchConfigs: o.eventNameDispatchConfigs, + registrationNameModules: o.registrationNameModules, + putListener: function(e, t, r) { + "production" !== n.env.NODE_ENV ? u(!r || "function" == typeof r, "Expected %s listener to be a function, instead got type %s", t, typeof r) : u(!r || "function" == typeof r); + var o = c[t] || (c[t] = {}); + o[e] = r + }, + getListener: function(e, t) { + var n = c[t]; + return n && n[e] + }, + deleteListener: function(e, t) { + var n = c[t]; + n && delete n[e] + }, + deleteAllListeners: function(e) { + for (var t in c) delete c[t][e] + }, + extractEvents: function(e, t, n, r) { + for (var a, s = o.plugins, u = 0, c = s.length; c > u; u++) { + var l = s[u]; + if (l) { + var p = l.extractEvents(e, t, n, r); + p && (a = i(a, p)) + } + } + return a + }, + enqueueEvents: function(e) { + e && (l = i(l, e)) + }, + processEventQueue: function() { + var e = l; + l = null, s(e, p), "production" !== n.env.NODE_ENV ? u(!l, "processEventQueue(): Additional events were enqueued while processing an event queue. Support for this has not yet been implemented.") : u(!l) + }, + __purge: function() { + c = {} + }, + __getListenerBank: function() { + return c + } + }; + t.exports = f + }).call(this, e("_process")) + }, { + "./EventPluginRegistry": 25, + "./EventPluginUtils": 26, + "./accumulateInto": 125, + "./forEachAccumulated": 142, + "./invariant": 157, + _process: 2 + }], + 25: [function(e, t) { + (function(n) { + "use strict"; + + function r() { + if (s) + for (var e in u) { + var t = u[e], + r = s.indexOf(e); + if ("production" !== n.env.NODE_ENV ? i(r > -1, "EventPluginRegistry: Cannot inject event plugins that do not exist in the plugin ordering, `%s`.", e) : i(r > -1), !c.plugins[r]) { + "production" !== n.env.NODE_ENV ? i(t.extractEvents, "EventPluginRegistry: Event plugins must implement an `extractEvents` method, but `%s` does not.", e) : i(t.extractEvents), c.plugins[r] = t; + var a = t.eventTypes; + for (var l in a) "production" !== n.env.NODE_ENV ? i(o(a[l], t, l), "EventPluginRegistry: Failed to publish event `%s` for plugin `%s`.", l, e) : i(o(a[l], t, l)) + } + } + } + + function o(e, t, r) { + "production" !== n.env.NODE_ENV ? i(!c.eventNameDispatchConfigs.hasOwnProperty(r), "EventPluginHub: More than one plugin attempted to publish the same event name, `%s`.", r) : i(!c.eventNameDispatchConfigs.hasOwnProperty(r)), c.eventNameDispatchConfigs[r] = e; + var o = e.phasedRegistrationNames; + if (o) { + for (var s in o) + if (o.hasOwnProperty(s)) { + var u = o[s]; + a(u, t, r) + } return !0 + } + return e.registrationName ? (a(e.registrationName, t, r), !0) : !1 + } + + function a(e, t, r) { + "production" !== n.env.NODE_ENV ? i(!c.registrationNameModules[e], "EventPluginHub: More than one plugin attempted to publish the same registration name, `%s`.", e) : i(!c.registrationNameModules[e]), c.registrationNameModules[e] = t, c.registrationNameDependencies[e] = t.eventTypes[r].dependencies + } + var i = e("./invariant"), + s = null, + u = {}, + c = { + plugins: [], + eventNameDispatchConfigs: {}, + registrationNameModules: {}, + registrationNameDependencies: {}, + injectEventPluginOrder: function(e) { + "production" !== n.env.NODE_ENV ? i(!s, "EventPluginRegistry: Cannot inject event plugin ordering more than once. You are likely trying to load more than one copy of React.") : i(!s), s = Array.prototype.slice.call(e), r() + }, + injectEventPluginsByName: function(e) { + var t = !1; + for (var o in e) + if (e.hasOwnProperty(o)) { + var a = e[o]; + u.hasOwnProperty(o) && u[o] === a || ("production" !== n.env.NODE_ENV ? i(!u[o], "EventPluginRegistry: Cannot inject two different event plugins using the same name, `%s`.", o) : i(!u[o]), u[o] = a, t = !0) + } t && r() + }, + getPluginModuleForEvent: function(e) { + var t = e.dispatchConfig; + if (t.registrationName) return c.registrationNameModules[t.registrationName] || null; + for (var n in t.phasedRegistrationNames) + if (t.phasedRegistrationNames.hasOwnProperty(n)) { + var r = c.registrationNameModules[t.phasedRegistrationNames[n]]; + if (r) return r + } return null + }, + _resetEventPlugins: function() { + s = null; + for (var e in u) u.hasOwnProperty(e) && delete u[e]; + c.plugins.length = 0; + var t = c.eventNameDispatchConfigs; + for (var n in t) t.hasOwnProperty(n) && delete t[n]; + var r = c.registrationNameModules; + for (var o in r) r.hasOwnProperty(o) && delete r[o] + } + }; + t.exports = c + }).call(this, e("_process")) + }, { + "./invariant": 157, + _process: 2 + }], + 26: [function(e, t) { + (function(n) { + "use strict"; + + function r(e) { + return e === y.topMouseUp || e === y.topTouchEnd || e === y.topTouchCancel + } + + function o(e) { + return e === y.topMouseMove || e === y.topTouchMove + } + + function a(e) { + return e === y.topMouseDown || e === y.topTouchStart + } + + function i(e, t) { + var r = e._dispatchListeners, + o = e._dispatchIDs; + if ("production" !== n.env.NODE_ENV && f(e), Array.isArray(r)) + for (var a = 0; a < r.length && !e.isPropagationStopped(); a++) t(e, r[a], o[a]); + else r && t(e, r, o) + } + + function s(e, t, n) { + e.currentTarget = m.Mount.getNode(n); + var r = t(e, n); + return e.currentTarget = null, r + } + + function u(e, t) { + i(e, t), e._dispatchListeners = null, e._dispatchIDs = null + } + + function c(e) { + var t = e._dispatchListeners, + r = e._dispatchIDs; + if ("production" !== n.env.NODE_ENV && f(e), Array.isArray(t)) { + for (var o = 0; o < t.length && !e.isPropagationStopped(); o++) + if (t[o](e, r[o])) return r[o] + } else if (t && t(e, r)) return r; + return null + } + + function l(e) { + var t = c(e); + return e._dispatchIDs = null, e._dispatchListeners = null, t + } + + function p(e) { + "production" !== n.env.NODE_ENV && f(e); + var t = e._dispatchListeners, + r = e._dispatchIDs; + "production" !== n.env.NODE_ENV ? v(!Array.isArray(t), "executeDirectDispatch(...): Invalid `event`.") : v(!Array.isArray(t)); + var o = t ? t(e, r) : null; + return e._dispatchListeners = null, e._dispatchIDs = null, o + } + + function d(e) { + return !!e._dispatchListeners + } + var f, h = e("./EventConstants"), + v = e("./invariant"), + m = { + Mount: null, + injectMount: function(e) { + m.Mount = e, "production" !== n.env.NODE_ENV && ("production" !== n.env.NODE_ENV ? v(e && e.getNode, "EventPluginUtils.injection.injectMount(...): Injected Mount module is missing getNode.") : v(e && e.getNode)) + } + }, + y = h.topLevelTypes; + "production" !== n.env.NODE_ENV && (f = function(e) { + var t = e._dispatchListeners, + r = e._dispatchIDs, + o = Array.isArray(t), + a = Array.isArray(r), + i = a ? r.length : r ? 1 : 0, + s = o ? t.length : t ? 1 : 0; + "production" !== n.env.NODE_ENV ? v(a === o && i === s, "EventPluginUtils: Invalid `event`.") : v(a === o && i === s) + }); + var g = { + isEndish: r, + isMoveish: o, + isStartish: a, + executeDirectDispatch: p, + executeDispatch: s, + executeDispatchesInOrder: u, + executeDispatchesInOrderStopAtTrue: l, + hasDispatches: d, + injection: m, + useTouchEvents: !1 + }; + t.exports = g + }).call(this, e("_process")) + }, { + "./EventConstants": 22, + "./invariant": 157, + _process: 2 + }], + 27: [function(e, t) { + (function(n) { + "use strict"; + + function r(e, t, n) { + var r = t.dispatchConfig.phasedRegistrationNames[n]; + return m(e, r) + } + + function o(e, t, o) { + if ("production" !== n.env.NODE_ENV && !e) throw new Error("Dispatching id must not be null"); + var a = t ? v.bubbled : v.captured, + i = r(e, o, a); + i && (o._dispatchListeners = f(o._dispatchListeners, i), o._dispatchIDs = f(o._dispatchIDs, e)) + } + + function a(e) { + e && e.dispatchConfig.phasedRegistrationNames && d.injection.getInstanceHandle().traverseTwoPhase(e.dispatchMarker, o, e) + } + + function i(e, t, n) { + if (n && n.dispatchConfig.registrationName) { + var r = n.dispatchConfig.registrationName, + o = m(e, r); + o && (n._dispatchListeners = f(n._dispatchListeners, o), n._dispatchIDs = f(n._dispatchIDs, e)) + } + } + + function s(e) { + e && e.dispatchConfig.registrationName && i(e.dispatchMarker, null, e) + } + + function u(e) { + h(e, a) + } + + function c(e, t, n, r) { + d.injection.getInstanceHandle().traverseEnterLeave(n, r, i, e, t) + } + + function l(e) { + h(e, s) + } + var p = e("./EventConstants"), + d = e("./EventPluginHub"), + f = e("./accumulateInto"), + h = e("./forEachAccumulated"), + v = p.PropagationPhases, + m = d.getListener, + y = { + accumulateTwoPhaseDispatches: u, + accumulateDirectDispatches: l, + accumulateEnterLeaveDispatches: c + }; + t.exports = y + }).call(this, e("_process")) + }, { + "./EventConstants": 22, + "./EventPluginHub": 24, + "./accumulateInto": 125, + "./forEachAccumulated": 142, + _process: 2 + }], + 28: [function(e, t) { + "use strict"; + var n = !("undefined" == typeof window || !window.document || !window.document.createElement), + r = { + canUseDOM: n, + canUseWorkers: "undefined" != typeof Worker, + canUseEventListeners: n && !(!window.addEventListener && !window.attachEvent), + canUseViewport: n && !!window.screen, + isInWorker: !n + }; + t.exports = r + }, {}], + 29: [function(e, t) { + "use strict"; + + function n(e) { + this._root = e, this._startText = this.getText(), this._fallbackText = null + } + var r = e("./PooledClass"), + o = e("./Object.assign"), + a = e("./getTextContentAccessor"); + o(n.prototype, { + getText: function() { + return "value" in this._root ? this._root.value : this._root[a()] + }, + getData: function() { + if (this._fallbackText) return this._fallbackText; + var e, t, n = this._startText, + r = n.length, + o = this.getText(), + a = o.length; + for (e = 0; r > e && n[e] === o[e]; e++); + var i = r - e; + for (t = 1; i >= t && n[r - t] === o[a - t]; t++); + var s = t > 1 ? 1 - t : void 0; + return this._fallbackText = o.slice(e, s), this._fallbackText + } + }), r.addPoolingTo(n), t.exports = n + }, { + "./Object.assign": 35, + "./PooledClass": 36, + "./getTextContentAccessor": 152 + }], + 30: [function(e, t) { + "use strict"; + var n, r = e("./DOMProperty"), + o = e("./ExecutionEnvironment"), + a = r.injection.MUST_USE_ATTRIBUTE, + i = r.injection.MUST_USE_PROPERTY, + s = r.injection.HAS_BOOLEAN_VALUE, + u = r.injection.HAS_SIDE_EFFECTS, + c = r.injection.HAS_NUMERIC_VALUE, + l = r.injection.HAS_POSITIVE_NUMERIC_VALUE, + p = r.injection.HAS_OVERLOADED_BOOLEAN_VALUE; + if (o.canUseDOM) { + var d = document.implementation; + n = d && d.hasFeature && d.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure", "1.1") + } + var f = { + isCustomAttribute: RegExp.prototype.test.bind(/^(data|aria)-[a-z_][a-z\d_.\-]*$/), + Properties: { + accept: null, + acceptCharset: null, + accessKey: null, + action: null, + allowFullScreen: a | s, + allowTransparency: a, + alt: null, + async: s, + autoComplete: null, + autoPlay: s, + cellPadding: null, + cellSpacing: null, + charSet: a, + checked: i | s, + classID: a, + className: n ? a : i, + cols: a | l, + colSpan: null, + content: null, + contentEditable: null, + contextMenu: a, + controls: i | s, + coords: null, + crossOrigin: null, + data: null, + dateTime: a, + defer: s, + dir: null, + disabled: a | s, + download: p, + draggable: null, + encType: null, + form: a, + formAction: a, + formEncType: a, + formMethod: a, + formNoValidate: s, + formTarget: a, + frameBorder: a, + headers: null, + height: a, + hidden: a | s, + href: null, + hrefLang: null, + htmlFor: null, + httpEquiv: null, + icon: null, + id: i, + label: null, + lang: null, + list: a, + loop: i | s, + manifest: a, + marginHeight: null, + marginWidth: null, + max: null, + maxLength: a, + media: a, + mediaGroup: null, + method: null, + min: null, + multiple: i | s, + muted: i | s, + name: null, + noValidate: s, + open: s, + pattern: null, + placeholder: null, + poster: null, + preload: null, + radioGroup: null, + readOnly: i | s, + rel: null, + required: s, + role: a, + rows: a | l, + rowSpan: null, + sandbox: null, + scope: null, + scrolling: null, + seamless: a | s, + selected: i | s, + shape: null, + size: a | l, + sizes: a, + span: l, + spellCheck: null, + src: null, + srcDoc: i, + srcSet: a, + start: c, + step: null, + style: null, + tabIndex: null, + target: null, + title: null, + type: null, + useMap: null, + value: i | u, + width: a, + wmode: a, + autoCapitalize: null, + autoCorrect: null, + itemProp: a, + itemScope: a | s, + itemType: a, + itemID: a, + itemRef: a, + property: null + }, + DOMAttributeNames: { + acceptCharset: "accept-charset", + className: "class", + htmlFor: "for", + httpEquiv: "http-equiv" + }, + DOMPropertyNames: { + autoCapitalize: "autocapitalize", + autoComplete: "autocomplete", + autoCorrect: "autocorrect", + autoFocus: "autofocus", + autoPlay: "autoplay", + encType: "encoding", + hrefLang: "hreflang", + radioGroup: "radiogroup", + spellCheck: "spellcheck", + srcDoc: "srcdoc", + srcSet: "srcset" + } + }; + t.exports = f + }, { + "./DOMProperty": 17, + "./ExecutionEnvironment": 28 + }], + 31: [function(e, t) { + "use strict"; + var n = e("./ReactLink"), + r = e("./ReactStateSetters"), + o = { + linkState: function(e) { + return new n(this.state[e], r.createStateKeySetter(this, e)) + } + }; + t.exports = o + }, { + "./ReactLink": 81, + "./ReactStateSetters": 100 + }], + 32: [function(e, t) { + (function(n) { + "use strict"; + + function r(e) { + "production" !== n.env.NODE_ENV ? c(null == e.props.checkedLink || null == e.props.valueLink, "Cannot provide a checkedLink and a valueLink. If you want to use checkedLink, you probably don't want to use valueLink and vice versa.") : c(null == e.props.checkedLink || null == e.props.valueLink) + } + + function o(e) { + r(e), "production" !== n.env.NODE_ENV ? c(null == e.props.value && null == e.props.onChange, "Cannot provide a valueLink and a value or onChange event. If you want to use value or onChange, you probably don't want to use valueLink.") : c(null == e.props.value && null == e.props.onChange) + } + + function a(e) { + r(e), "production" !== n.env.NODE_ENV ? c(null == e.props.checked && null == e.props.onChange, "Cannot provide a checkedLink and a checked property or onChange event. If you want to use checked or onChange, you probably don't want to use checkedLink") : c(null == e.props.checked && null == e.props.onChange) + } + + function i(e) { + this.props.valueLink.requestChange(e.target.value) + } + + function s(e) { + this.props.checkedLink.requestChange(e.target.checked) + } + var u = e("./ReactPropTypes"), + c = e("./invariant"), + l = { + button: !0, + checkbox: !0, + image: !0, + hidden: !0, + radio: !0, + reset: !0, + submit: !0 + }, + p = { + Mixin: { + propTypes: { + value: function(e, t) { + return !e[t] || l[e.type] || e.onChange || e.readOnly || e.disabled ? null : new Error("You provided a `value` prop to a form field without an `onChange` handler. This will render a read-only field. If the field should be mutable use `defaultValue`. Otherwise, set either `onChange` or `readOnly`.") + }, + checked: function(e, t) { + return !e[t] || e.onChange || e.readOnly || e.disabled ? null : new Error("You provided a `checked` prop to a form field without an `onChange` handler. This will render a read-only field. If the field should be mutable use `defaultChecked`. Otherwise, set either `onChange` or `readOnly`.") + }, + onChange: u.func + } + }, + getValue: function(e) { + return e.props.valueLink ? (o(e), e.props.valueLink.value) : e.props.value + }, + getChecked: function(e) { + return e.props.checkedLink ? (a(e), e.props.checkedLink.value) : e.props.checked + }, + getOnChange: function(e) { + return e.props.valueLink ? (o(e), i) : e.props.checkedLink ? (a(e), s) : e.props.onChange + } + }; + t.exports = p + }).call(this, e("_process")) + }, { + "./ReactPropTypes": 92, + "./invariant": 157, + _process: 2 + }], + 33: [function(e, t) { + (function(n) { + "use strict"; + + function r(e) { + e.remove() + } + var o = e("./ReactBrowserEventEmitter"), + a = e("./accumulateInto"), + i = e("./forEachAccumulated"), + s = e("./invariant"), + u = { + trapBubbledEvent: function(e, t) { + "production" !== n.env.NODE_ENV ? s(this.isMounted(), "Must be mounted to trap events") : s(this.isMounted()); + var r = this.getDOMNode(); + "production" !== n.env.NODE_ENV ? s(r, "LocalEventTrapMixin.trapBubbledEvent(...): Requires node to be rendered.") : s(r); + var i = o.trapBubbledEvent(e, t, r); + this._localEventListeners = a(this._localEventListeners, i) + }, + componentWillUnmount: function() { + this._localEventListeners && i(this._localEventListeners, r) + } + }; + t.exports = u + }).call(this, e("_process")) + }, { + "./ReactBrowserEventEmitter": 39, + "./accumulateInto": 125, + "./forEachAccumulated": 142, + "./invariant": 157, + _process: 2 + }], + 34: [function(e, t) { + "use strict"; + var n = e("./EventConstants"), + r = e("./emptyFunction"), + o = n.topLevelTypes, + a = { + eventTypes: null, + extractEvents: function(e, t, n, a) { + if (e === o.topTouchStart) { + var i = a.target; + i && !i.onclick && (i.onclick = r) + } + } + }; + t.exports = a + }, { + "./EventConstants": 22, + "./emptyFunction": 136 + }], + 35: [function(e, t) { + "use strict"; + + function n(e) { + if (null == e) throw new TypeError("Object.assign target cannot be null or undefined"); + for (var t = Object(e), n = Object.prototype.hasOwnProperty, r = 1; r < arguments.length; r++) { + var o = arguments[r]; + if (null != o) { + var a = Object(o); + for (var i in a) n.call(a, i) && (t[i] = a[i]) + } + } + return t + } + t.exports = n + }, {}], + 36: [function(e, t) { + (function(n) { + "use strict"; + var r = e("./invariant"), + o = function(e) { + var t = this; + if (t.instancePool.length) { + var n = t.instancePool.pop(); + return t.call(n, e), n + } + return new t(e) + }, + a = function(e, t) { + var n = this; + if (n.instancePool.length) { + var r = n.instancePool.pop(); + return n.call(r, e, t), r + } + return new n(e, t) + }, + i = function(e, t, n) { + var r = this; + if (r.instancePool.length) { + var o = r.instancePool.pop(); + return r.call(o, e, t, n), o + } + return new r(e, t, n) + }, + s = function(e, t, n, r, o) { + var a = this; + if (a.instancePool.length) { + var i = a.instancePool.pop(); + return a.call(i, e, t, n, r, o), i + } + return new a(e, t, n, r, o) + }, + u = function(e) { + var t = this; + "production" !== n.env.NODE_ENV ? r(e instanceof t, "Trying to release an instance into a pool of a different type.") : r(e instanceof t), e.destructor && e.destructor(), t.instancePool.length < t.poolSize && t.instancePool.push(e) + }, + c = 10, + l = o, + p = function(e, t) { + var n = e; + return n.instancePool = [], n.getPooled = t || l, n.poolSize || (n.poolSize = c), n.release = u, n + }, + d = { + addPoolingTo: p, + oneArgumentPooler: o, + twoArgumentPooler: a, + threeArgumentPooler: i, + fiveArgumentPooler: s + }; + t.exports = d + }).call(this, e("_process")) + }, { + "./invariant": 157, + _process: 2 + }], + 37: [function(e, t) { + (function(n) { + "use strict"; + var r = e("./EventPluginUtils"), + o = e("./ReactChildren"), + a = e("./ReactComponent"), + i = e("./ReactClass"), + s = e("./ReactContext"), + u = e("./ReactCurrentOwner"), + c = e("./ReactElement"), + l = e("./ReactElementValidator"), + p = e("./ReactDOM"), + d = e("./ReactDOMTextComponent"), + f = e("./ReactDefaultInjection"), + h = e("./ReactInstanceHandles"), + v = e("./ReactMount"), + m = e("./ReactPerf"), + y = e("./ReactPropTypes"), + g = e("./ReactReconciler"), + E = e("./ReactServerRendering"), + C = e("./Object.assign"), + b = e("./findDOMNode"), + _ = e("./onlyChild"); + f.inject(); + var N = c.createElement, + O = c.createFactory, + R = c.cloneElement; + "production" !== n.env.NODE_ENV && (N = l.createElement, O = l.createFactory, R = l.cloneElement); + var D = m.measure("React", "render", v.render), + w = { + Children: { + map: o.map, + forEach: o.forEach, + count: o.count, + only: _ + }, + Component: a, + DOM: p, + PropTypes: y, + initializeTouchEvents: function(e) { + r.useTouchEvents = e + }, + createClass: i.createClass, + createElement: N, + cloneElement: R, + createFactory: O, + createMixin: function(e) { + return e + }, + constructAndRenderComponent: v.constructAndRenderComponent, + constructAndRenderComponentByID: v.constructAndRenderComponentByID, + findDOMNode: b, + render: D, + renderToString: E.renderToString, + renderToStaticMarkup: E.renderToStaticMarkup, + unmountComponentAtNode: v.unmountComponentAtNode, + isValidElement: c.isValidElement, + withContext: s.withContext, + __spread: C + }; + if ("undefined" != typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" == typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.inject && __REACT_DEVTOOLS_GLOBAL_HOOK__.inject({ + CurrentOwner: u, + InstanceHandles: h, + Mount: v, + Reconciler: g, + TextComponent: d + }), "production" !== n.env.NODE_ENV) { + var M = e("./ExecutionEnvironment"); + if (M.canUseDOM && window.top === window.self) { + navigator.userAgent.indexOf("Chrome") > -1 && "undefined" == typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && console.debug("Download the React DevTools for a better development experience: http://fb.me/react-devtools"); + for (var x = [Array.isArray, Array.prototype.every, Array.prototype.forEach, Array.prototype.indexOf, Array.prototype.map, Date.now, Function.prototype.bind, Object.keys, String.prototype.split, String.prototype.trim, Object.create, Object.freeze], T = 0; T < x.length; T++) + if (!x[T]) { + console.error("One or more ES5 shim/shams expected by React are not available: http://fb.me/react-warning-polyfills"); + break + } + } + } + w.version = "0.13.1", t.exports = w + }).call(this, e("_process")) + }, { + "./EventPluginUtils": 26, + "./ExecutionEnvironment": 28, + "./Object.assign": 35, + "./ReactChildren": 43, + "./ReactClass": 44, + "./ReactComponent": 45, + "./ReactContext": 50, + "./ReactCurrentOwner": 51, + "./ReactDOM": 52, + "./ReactDOMTextComponent": 63, + "./ReactDefaultInjection": 66, + "./ReactElement": 69, + "./ReactElementValidator": 70, + "./ReactInstanceHandles": 78, + "./ReactMount": 83, + "./ReactPerf": 88, + "./ReactPropTypes": 92, + "./ReactReconciler": 95, + "./ReactServerRendering": 98, + "./findDOMNode": 139, + "./onlyChild": 167, + _process: 2 + }], + 38: [function(e, t) { + "use strict"; + var n = e("./findDOMNode"), + r = { + getDOMNode: function() { + return n(this) + } + }; + t.exports = r + }, { + "./findDOMNode": 139 + }], + 39: [function(e, t) { + "use strict"; + + function n(e) { + return Object.prototype.hasOwnProperty.call(e, h) || (e[h] = d++, l[e[h]] = {}), l[e[h]] + } + var r = e("./EventConstants"), + o = e("./EventPluginHub"), + a = e("./EventPluginRegistry"), + i = e("./ReactEventEmitterMixin"), + s = e("./ViewportMetrics"), + u = e("./Object.assign"), + c = e("./isEventSupported"), + l = {}, + p = !1, + d = 0, + f = { + topBlur: "blur", + topChange: "change", + topClick: "click", + topCompositionEnd: "compositionend", + topCompositionStart: "compositionstart", + topCompositionUpdate: "compositionupdate", + topContextMenu: "contextmenu", + topCopy: "copy", + topCut: "cut", + topDoubleClick: "dblclick", + topDrag: "drag", + topDragEnd: "dragend", + topDragEnter: "dragenter", + topDragExit: "dragexit", + topDragLeave: "dragleave", + topDragOver: "dragover", + topDragStart: "dragstart", + topDrop: "drop", + topFocus: "focus", + topInput: "input", + topKeyDown: "keydown", + topKeyPress: "keypress", + topKeyUp: "keyup", + topMouseDown: "mousedown", + topMouseMove: "mousemove", + topMouseOut: "mouseout", + topMouseOver: "mouseover", + topMouseUp: "mouseup", + topPaste: "paste", + topScroll: "scroll", + topSelectionChange: "selectionchange", + topTextInput: "textInput", + topTouchCancel: "touchcancel", + topTouchEnd: "touchend", + topTouchMove: "touchmove", + topTouchStart: "touchstart", + topWheel: "wheel" + }, + h = "_reactListenersID" + String(Math.random()).slice(2), + v = u({}, i, { + ReactEventListener: null, + injection: { + injectReactEventListener: function(e) { + e.setHandleTopLevel(v.handleTopLevel), v.ReactEventListener = e + } + }, + setEnabled: function(e) { + v.ReactEventListener && v.ReactEventListener.setEnabled(e) + }, + isEnabled: function() { + return !(!v.ReactEventListener || !v.ReactEventListener.isEnabled()) + }, + listenTo: function(e, t) { + for (var o = t, i = n(o), s = a.registrationNameDependencies[e], u = r.topLevelTypes, l = 0, p = s.length; p > l; l++) { + var d = s[l]; + i.hasOwnProperty(d) && i[d] || (d === u.topWheel ? c("wheel") ? v.ReactEventListener.trapBubbledEvent(u.topWheel, "wheel", o) : c("mousewheel") ? v.ReactEventListener.trapBubbledEvent(u.topWheel, "mousewheel", o) : v.ReactEventListener.trapBubbledEvent(u.topWheel, "DOMMouseScroll", o) : d === u.topScroll ? c("scroll", !0) ? v.ReactEventListener.trapCapturedEvent(u.topScroll, "scroll", o) : v.ReactEventListener.trapBubbledEvent(u.topScroll, "scroll", v.ReactEventListener.WINDOW_HANDLE) : d === u.topFocus || d === u.topBlur ? (c("focus", !0) ? (v.ReactEventListener.trapCapturedEvent(u.topFocus, "focus", o), v.ReactEventListener.trapCapturedEvent(u.topBlur, "blur", o)) : c("focusin") && (v.ReactEventListener.trapBubbledEvent(u.topFocus, "focusin", o), v.ReactEventListener.trapBubbledEvent(u.topBlur, "focusout", o)), i[u.topBlur] = !0, i[u.topFocus] = !0) : f.hasOwnProperty(d) && v.ReactEventListener.trapBubbledEvent(d, f[d], o), i[d] = !0) + } + }, + trapBubbledEvent: function(e, t, n) { + return v.ReactEventListener.trapBubbledEvent(e, t, n) + }, + trapCapturedEvent: function(e, t, n) { + return v.ReactEventListener.trapCapturedEvent(e, t, n) + }, + ensureScrollValueMonitoring: function() { + if (!p) { + var e = s.refreshScrollValues; + v.ReactEventListener.monitorScrollValue(e), p = !0 + } + }, + eventNameDispatchConfigs: o.eventNameDispatchConfigs, + registrationNameModules: o.registrationNameModules, + putListener: o.putListener, + getListener: o.getListener, + deleteListener: o.deleteListener, + deleteAllListeners: o.deleteAllListeners + }); + t.exports = v + }, { + "./EventConstants": 22, + "./EventPluginHub": 24, + "./EventPluginRegistry": 25, + "./Object.assign": 35, + "./ReactEventEmitterMixin": 73, + "./ViewportMetrics": 124, + "./isEventSupported": 158 + }], + 40: [function(e, t) { + "use strict"; + var n = e("./React"), + r = e("./Object.assign"), + o = n.createFactory(e("./ReactTransitionGroup")), + a = n.createFactory(e("./ReactCSSTransitionGroupChild")), + i = n.createClass({ + displayName: "ReactCSSTransitionGroup", + propTypes: { + transitionName: n.PropTypes.string.isRequired, + transitionAppear: n.PropTypes.bool, + transitionEnter: n.PropTypes.bool, + transitionLeave: n.PropTypes.bool + }, + getDefaultProps: function() { + return { + transitionAppear: !1, + transitionEnter: !0, + transitionLeave: !0 + } + }, + _wrapChild: function(e) { + return a({ + name: this.props.transitionName, + appear: this.props.transitionAppear, + enter: this.props.transitionEnter, + leave: this.props.transitionLeave + }, e) + }, + render: function() { + return o(r({}, this.props, { + childFactory: this._wrapChild + })) + } + }); + t.exports = i + }, { + "./Object.assign": 35, + "./React": 37, + "./ReactCSSTransitionGroupChild": 41, + "./ReactTransitionGroup": 104 + }], + 41: [function(e, t) { + (function(n) { + "use strict"; + var r = e("./React"), + o = e("./CSSCore"), + a = e("./ReactTransitionEvents"), + i = e("./onlyChild"), + s = e("./warning"), + u = 17, + c = 5e3, + l = null; + "production" !== n.env.NODE_ENV && (l = function() { + "production" !== n.env.NODE_ENV ? s(!1, "transition(): tried to perform an animation without an animationend or transitionend event after timeout (%sms). You should either disable this transition in JS or add a CSS animation/transition.", c) : null + }); + var p = r.createClass({ + displayName: "ReactCSSTransitionGroupChild", + transition: function(e, t) { + var r = this.getDOMNode(), + i = this.props.name + "-" + e, + s = i + "-active", + u = null, + p = function(e) { + e && e.target !== r || ("production" !== n.env.NODE_ENV && clearTimeout(u), o.removeClass(r, i), o.removeClass(r, s), a.removeEndEventListener(r, p), t && t()) + }; + a.addEndEventListener(r, p), o.addClass(r, i), this.queueClass(s), "production" !== n.env.NODE_ENV && (u = setTimeout(l, c)) + }, + queueClass: function(e) { + this.classNameQueue.push(e), this.timeout || (this.timeout = setTimeout(this.flushClassNameQueue, u)) + }, + flushClassNameQueue: function() { + this.isMounted() && this.classNameQueue.forEach(o.addClass.bind(o, this.getDOMNode())), this.classNameQueue.length = 0, this.timeout = null + }, + componentWillMount: function() { + this.classNameQueue = [] + }, + componentWillUnmount: function() { + this.timeout && clearTimeout(this.timeout) + }, + componentWillAppear: function(e) { + this.props.appear ? this.transition("appear", e) : e() + }, + componentWillEnter: function(e) { + this.props.enter ? this.transition("enter", e) : e() + }, + componentWillLeave: function(e) { + this.props.leave ? this.transition("leave", e) : e() + }, + render: function() { + return i(this.props.children) + } + }); + t.exports = p + }).call(this, e("_process")) + }, { + "./CSSCore": 10, + "./React": 37, + "./ReactTransitionEvents": 103, + "./onlyChild": 167, + "./warning": 178, + _process: 2 + }], + 42: [function(e, t) { + "use strict"; + var n = e("./ReactReconciler"), + r = e("./flattenChildren"), + o = e("./instantiateReactComponent"), + a = e("./shouldUpdateReactComponent"), + i = { + instantiateChildren: function(e) { + var t = r(e); + for (var n in t) + if (t.hasOwnProperty(n)) { + var a = t[n], + i = o(a, null); + t[n] = i + } return t + }, + updateChildren: function(e, t, i, s) { + var u = r(t); + if (!u && !e) return null; + var c; + for (c in u) + if (u.hasOwnProperty(c)) { + var l = e && e[c], + p = l && l._currentElement, + d = u[c]; + if (a(p, d)) n.receiveComponent(l, d, i, s), u[c] = l; + else { + l && n.unmountComponent(l, c); + var f = o(d, null); + u[c] = f + } + } for (c in e) !e.hasOwnProperty(c) || u && u.hasOwnProperty(c) || n.unmountComponent(e[c]); + return u + }, + unmountChildren: function(e) { + for (var t in e) { + var r = e[t]; + n.unmountComponent(r) + } + } + }; + t.exports = i + }, { + "./ReactReconciler": 95, + "./flattenChildren": 140, + "./instantiateReactComponent": 156, + "./shouldUpdateReactComponent": 174 + }], + 43: [function(e, t) { + (function(n) { + "use strict"; + + function r(e, t) { + this.forEachFunction = e, this.forEachContext = t + } + + function o(e, t, n, r) { + var o = e; + o.forEachFunction.call(o.forEachContext, t, r) + } + + function a(e, t, n) { + if (null == e) return e; + var a = r.getPooled(t, n); + f(e, o, a), r.release(a) + } + + function i(e, t, n) { + this.mapResult = e, this.mapFunction = t, this.mapContext = n + } + + function s(e, t, r, o) { + var a = e, + i = a.mapResult, + s = !i.hasOwnProperty(r); + if ("production" !== n.env.NODE_ENV && ("production" !== n.env.NODE_ENV ? h(s, "ReactChildren.map(...): Encountered two children with the same key, `%s`. Child keys must be unique; when two children share a key, only the first child will be used.", r) : null), s) { + var u = a.mapFunction.call(a.mapContext, t, o); + i[r] = u + } + } + + function u(e, t, n) { + if (null == e) return e; + var r = {}, + o = i.getPooled(r, t, n); + return f(e, s, o), i.release(o), d.create(r) + } + + function c() { + return null + } + + function l(e) { + return f(e, c, null) + } + var p = e("./PooledClass"), + d = e("./ReactFragment"), + f = e("./traverseAllChildren"), + h = e("./warning"), + v = p.twoArgumentPooler, + m = p.threeArgumentPooler; + p.addPoolingTo(r, v), p.addPoolingTo(i, m); + var y = { + forEach: a, + map: u, + count: l + }; + t.exports = y + }).call(this, e("_process")) + }, { + "./PooledClass": 36, + "./ReactFragment": 75, + "./traverseAllChildren": 176, + "./warning": 178, + _process: 2 + }], + 44: [function(e, t) { + (function(n) { + "use strict"; + + function r(e, t, r) { + for (var o in t) t.hasOwnProperty(o) && ("production" !== n.env.NODE_ENV ? R("function" == typeof t[o], "%s: %s type `%s` is invalid; it must be a function, usually from React.PropTypes.", e.displayName || "ReactClass", E[r], o) : null) + } + + function o(e, t) { + var r = x.hasOwnProperty(t) ? x[t] : null; + I.hasOwnProperty(t) && ("production" !== n.env.NODE_ENV ? _(r === w.OVERRIDE_BASE, "ReactClassInterface: You are attempting to override `%s` from your class specification. Ensure that your method names do not overlap with React methods.", t) : _(r === w.OVERRIDE_BASE)), e.hasOwnProperty(t) && ("production" !== n.env.NODE_ENV ? _(r === w.DEFINE_MANY || r === w.DEFINE_MANY_MERGED, "ReactClassInterface: You are attempting to define `%s` on your component more than once. This conflict may be due to a mixin.", t) : _(r === w.DEFINE_MANY || r === w.DEFINE_MANY_MERGED)) + } + + function a(e, t) { + if (t) { + "production" !== n.env.NODE_ENV ? _("function" != typeof t, "ReactClass: You're attempting to use a component class as a mixin. Instead, just use a regular object.") : _("function" != typeof t), "production" !== n.env.NODE_ENV ? _(!h.isValidElement(t), "ReactClass: You're attempting to use a component as a mixin. Instead, just use a regular object.") : _(!h.isValidElement(t)); + var r = e.prototype; + t.hasOwnProperty(D) && T.mixins(e, t.mixins); + for (var a in t) + if (t.hasOwnProperty(a) && a !== D) { + var i = t[a]; + if (o(r, a), T.hasOwnProperty(a)) T[a](e, i); + else { + var s = x.hasOwnProperty(a), + l = r.hasOwnProperty(a), + p = i && i.__reactDontBind, + d = "function" == typeof i, + f = d && !s && !l && !p; + if (f) r.__reactAutoBindMap || (r.__reactAutoBindMap = {}), r.__reactAutoBindMap[a] = i, r[a] = i; + else if (l) { + var v = x[a]; + "production" !== n.env.NODE_ENV ? _(s && (v === w.DEFINE_MANY_MERGED || v === w.DEFINE_MANY), "ReactClass: Unexpected spec policy %s for key %s when mixing in component specs.", v, a) : _(s && (v === w.DEFINE_MANY_MERGED || v === w.DEFINE_MANY)), v === w.DEFINE_MANY_MERGED ? r[a] = u(r[a], i) : v === w.DEFINE_MANY && (r[a] = c(r[a], i)) + } else r[a] = i, "production" !== n.env.NODE_ENV && "function" == typeof i && t.displayName && (r[a].displayName = t.displayName + "_" + a) + } + } + } + } + + function i(e, t) { + if (t) + for (var r in t) { + var o = t[r]; + if (t.hasOwnProperty(r)) { + var a = r in T; + "production" !== n.env.NODE_ENV ? _(!a, 'ReactClass: You are attempting to define a reserved property, `%s`, that shouldn\'t be on the "statics" key. Define it as an instance property instead; it will still be accessible on the constructor.', r) : _(!a); + var i = r in e; + "production" !== n.env.NODE_ENV ? _(!i, "ReactClass: You are attempting to define `%s` on your component more than once. This conflict may be due to a mixin.", r) : _(!i), e[r] = o + } + } + } + + function s(e, t) { + "production" !== n.env.NODE_ENV ? _(e && t && "object" == typeof e && "object" == typeof t, "mergeIntoWithNoDuplicateKeys(): Cannot merge non-objects.") : _(e && t && "object" == typeof e && "object" == typeof t); + for (var r in t) t.hasOwnProperty(r) && ("production" !== n.env.NODE_ENV ? _(void 0 === e[r], "mergeIntoWithNoDuplicateKeys(): Tried to merge two objects with the same key: `%s`. This conflict may be due to a mixin; in particular, this may be caused by two getInitialState() or getDefaultProps() methods returning objects with clashing keys.", r) : _(void 0 === e[r]), e[r] = t[r]); + return e + } + + function u(e, t) { + return function() { + var n = e.apply(this, arguments), + r = t.apply(this, arguments); + if (null == n) return r; + if (null == r) return n; + var o = {}; + return s(o, n), s(o, r), o + } + } + + function c(e, t) { + return function() { + e.apply(this, arguments), t.apply(this, arguments) + } + } + + function l(e, t) { + var r = t.bind(e); + if ("production" !== n.env.NODE_ENV) { + r.__reactBoundContext = e, r.__reactBoundMethod = t, r.__reactBoundArguments = null; + var o = e.constructor.displayName, + a = r.bind; + r.bind = function(i) { + for (var s = [], u = 1, c = arguments.length; c > u; u++) s.push(arguments[u]); + if (i !== e && null !== i) "production" !== n.env.NODE_ENV ? R(!1, "bind(): React component methods may only be bound to the component instance. See %s", o) : null; + else if (!s.length) return "production" !== n.env.NODE_ENV ? R(!1, "bind(): You are binding a component method to the component. React does this for you automatically in a high-performance way, so you can safely remove this call. See %s", o) : null, r; + var l = a.apply(r, arguments); + return l.__reactBoundContext = e, l.__reactBoundMethod = t, l.__reactBoundArguments = s, l + } + } + return r + } + + function p(e) { + for (var t in e.__reactAutoBindMap) + if (e.__reactAutoBindMap.hasOwnProperty(t)) { + var n = e.__reactAutoBindMap[t]; + e[t] = l(e, v.guard(n, e.constructor.displayName + "." + t)) + } + } + var d = e("./ReactComponent"), + f = e("./ReactCurrentOwner"), + h = e("./ReactElement"), + v = e("./ReactErrorUtils"), + m = e("./ReactInstanceMap"), + y = e("./ReactLifeCycle"), + g = e("./ReactPropTypeLocations"), + E = e("./ReactPropTypeLocationNames"), + C = e("./ReactUpdateQueue"), + b = e("./Object.assign"), + _ = e("./invariant"), + N = e("./keyMirror"), + O = e("./keyOf"), + R = e("./warning"), + D = O({ + mixins: null + }), + w = N({ + DEFINE_ONCE: null, + DEFINE_MANY: null, + OVERRIDE_BASE: null, + DEFINE_MANY_MERGED: null + }), + M = [], + x = { + mixins: w.DEFINE_MANY, + statics: w.DEFINE_MANY, + propTypes: w.DEFINE_MANY, + contextTypes: w.DEFINE_MANY, + childContextTypes: w.DEFINE_MANY, + getDefaultProps: w.DEFINE_MANY_MERGED, + getInitialState: w.DEFINE_MANY_MERGED, + getChildContext: w.DEFINE_MANY_MERGED, + render: w.DEFINE_ONCE, + componentWillMount: w.DEFINE_MANY, + componentDidMount: w.DEFINE_MANY, + componentWillReceiveProps: w.DEFINE_MANY, + shouldComponentUpdate: w.DEFINE_ONCE, + componentWillUpdate: w.DEFINE_MANY, + componentDidUpdate: w.DEFINE_MANY, + componentWillUnmount: w.DEFINE_MANY, + updateComponent: w.OVERRIDE_BASE + }, + T = { + displayName: function(e, t) { + e.displayName = t + }, + mixins: function(e, t) { + if (t) + for (var n = 0; n < t.length; n++) a(e, t[n]) + }, + childContextTypes: function(e, t) { + "production" !== n.env.NODE_ENV && r(e, t, g.childContext), e.childContextTypes = b({}, e.childContextTypes, t) + }, + contextTypes: function(e, t) { + "production" !== n.env.NODE_ENV && r(e, t, g.context), e.contextTypes = b({}, e.contextTypes, t) + }, + getDefaultProps: function(e, t) { + e.getDefaultProps = e.getDefaultProps ? u(e.getDefaultProps, t) : t; + + }, + propTypes: function(e, t) { + "production" !== n.env.NODE_ENV && r(e, t, g.prop), e.propTypes = b({}, e.propTypes, t) + }, + statics: function(e, t) { + i(e, t) + } + }, + P = { + enumerable: !1, + get: function() { + var e = this.displayName || this.name || "Component"; + return "production" !== n.env.NODE_ENV ? R(!1, "%s.type is deprecated. Use %s directly to access the class.", e, e) : null, Object.defineProperty(this, "type", { + value: this + }), this + } + }, + I = { + replaceState: function(e, t) { + C.enqueueReplaceState(this, e), t && C.enqueueCallback(this, t) + }, + isMounted: function() { + if ("production" !== n.env.NODE_ENV) { + var e = f.current; + null !== e && ("production" !== n.env.NODE_ENV ? R(e._warnedAboutRefsInRender, "%s is accessing isMounted inside its render() function. render() should be a pure function of props and state. It should never access something that requires stale data from the previous render, such as refs. Move this logic to componentDidMount and componentDidUpdate instead.", e.getName() || "A component") : null, e._warnedAboutRefsInRender = !0) + } + var t = m.get(this); + return t && t !== y.currentlyMountingInstance + }, + setProps: function(e, t) { + C.enqueueSetProps(this, e), t && C.enqueueCallback(this, t) + }, + replaceProps: function(e, t) { + C.enqueueReplaceProps(this, e), t && C.enqueueCallback(this, t) + } + }, + S = function() {}; + b(S.prototype, d.prototype, I); + var k = { + createClass: function(e) { + var t = function(e, r) { + "production" !== n.env.NODE_ENV && ("production" !== n.env.NODE_ENV ? R(this instanceof t, "Something is calling a React component directly. Use a factory or JSX instead. See: http://fb.me/react-legacyfactory") : null), this.__reactAutoBindMap && p(this), this.props = e, this.context = r, this.state = null; + var o = this.getInitialState ? this.getInitialState() : null; + "production" !== n.env.NODE_ENV && "undefined" == typeof o && this.getInitialState._isMockFunction && (o = null), "production" !== n.env.NODE_ENV ? _("object" == typeof o && !Array.isArray(o), "%s.getInitialState(): must return an object or null", t.displayName || "ReactCompositeComponent") : _("object" == typeof o && !Array.isArray(o)), this.state = o + }; + t.prototype = new S, t.prototype.constructor = t, M.forEach(a.bind(null, t)), a(t, e), t.getDefaultProps && (t.defaultProps = t.getDefaultProps()), "production" !== n.env.NODE_ENV && (t.getDefaultProps && (t.getDefaultProps.isReactClassApproved = {}), t.prototype.getInitialState && (t.prototype.getInitialState.isReactClassApproved = {})), "production" !== n.env.NODE_ENV ? _(t.prototype.render, "createClass(...): Class specification must implement a `render` method.") : _(t.prototype.render), "production" !== n.env.NODE_ENV && ("production" !== n.env.NODE_ENV ? R(!t.prototype.componentShouldUpdate, "%s has a method called componentShouldUpdate(). Did you mean shouldComponentUpdate()? The name is phrased as a question because the function is expected to return a value.", e.displayName || "A component") : null); + for (var r in x) t.prototype[r] || (t.prototype[r] = null); + if (t.type = t, "production" !== n.env.NODE_ENV) try { + Object.defineProperty(t, "type", P) + } catch (o) {} + return t + }, + injection: { + injectMixin: function(e) { + M.push(e) + } + } + }; + t.exports = k + }).call(this, e("_process")) + }, { + "./Object.assign": 35, + "./ReactComponent": 45, + "./ReactCurrentOwner": 51, + "./ReactElement": 69, + "./ReactErrorUtils": 72, + "./ReactInstanceMap": 79, + "./ReactLifeCycle": 80, + "./ReactPropTypeLocationNames": 90, + "./ReactPropTypeLocations": 91, + "./ReactUpdateQueue": 105, + "./invariant": 157, + "./keyMirror": 163, + "./keyOf": 164, + "./warning": 178, + _process: 2 + }], + 45: [function(e, t) { + (function(n) { + "use strict"; + + function r(e, t) { + this.props = e, this.context = t + } + var o = e("./ReactUpdateQueue"), + a = e("./invariant"), + i = e("./warning"); + if (r.prototype.setState = function(e, t) { + "production" !== n.env.NODE_ENV ? a("object" == typeof e || "function" == typeof e || null == e, "setState(...): takes an object of state variables to update or a function which returns an object of state variables.") : a("object" == typeof e || "function" == typeof e || null == e), "production" !== n.env.NODE_ENV && ("production" !== n.env.NODE_ENV ? i(null != e, "setState(...): You passed an undefined or null state object; instead, use forceUpdate().") : null), o.enqueueSetState(this, e), t && o.enqueueCallback(this, t) + }, r.prototype.forceUpdate = function(e) { + o.enqueueForceUpdate(this), e && o.enqueueCallback(this, e) + }, "production" !== n.env.NODE_ENV) { + var s = { + getDOMNode: "getDOMNode", + isMounted: "isMounted", + replaceProps: "replaceProps", + replaceState: "replaceState", + setProps: "setProps" + }, + u = function(e, t) { + try { + Object.defineProperty(r.prototype, e, { + get: function() { + return void("production" !== n.env.NODE_ENV ? i(!1, "%s(...) is deprecated in plain JavaScript React classes.", t) : null) + } + }) + } catch (o) {} + }; + for (var c in s) s.hasOwnProperty(c) && u(c, s[c]) + } + t.exports = r + }).call(this, e("_process")) + }, { + "./ReactUpdateQueue": 105, + "./invariant": 157, + "./warning": 178, + _process: 2 + }], + 46: [function(e, t) { + "use strict"; + var n = e("./ReactDOMIDOperations"), + r = e("./ReactMount"), + o = { + processChildrenUpdates: n.dangerouslyProcessChildrenUpdates, + replaceNodeWithMarkupByID: n.dangerouslyReplaceNodeWithMarkupByID, + unmountIDFromEnvironment: function(e) { + r.purgeID(e) + } + }; + t.exports = o + }, { + "./ReactDOMIDOperations": 56, + "./ReactMount": 83 + }], + 47: [function(e, t) { + (function(n) { + "use strict"; + var r = e("./invariant"), + o = !1, + a = { + unmountIDFromEnvironment: null, + replaceNodeWithMarkupByID: null, + processChildrenUpdates: null, + injection: { + injectEnvironment: function(e) { + "production" !== n.env.NODE_ENV ? r(!o, "ReactCompositeComponent: injectEnvironment() can only be called once.") : r(!o), a.unmountIDFromEnvironment = e.unmountIDFromEnvironment, a.replaceNodeWithMarkupByID = e.replaceNodeWithMarkupByID, a.processChildrenUpdates = e.processChildrenUpdates, o = !0 + } + } + }; + t.exports = a + }).call(this, e("_process")) + }, { + "./invariant": 157, + _process: 2 + }], + 48: [function(e, t) { + "use strict"; + var n = e("./shallowEqual"), + r = { + shouldComponentUpdate: function(e, t) { + return !n(this.props, e) || !n(this.state, t) + } + }; + t.exports = r + }, { + "./shallowEqual": 173 + }], + 49: [function(e, t) { + (function(n) { + "use strict"; + + function r(e) { + var t = e._currentElement._owner || null; + if (t) { + var n = t.getName(); + if (n) return " Check the render method of `" + n + "`." + } + return "" + } + var o = e("./ReactComponentEnvironment"), + a = e("./ReactContext"), + i = e("./ReactCurrentOwner"), + s = e("./ReactElement"), + u = e("./ReactElementValidator"), + c = e("./ReactInstanceMap"), + l = e("./ReactLifeCycle"), + p = e("./ReactNativeComponent"), + d = e("./ReactPerf"), + f = e("./ReactPropTypeLocations"), + h = e("./ReactPropTypeLocationNames"), + v = e("./ReactReconciler"), + m = e("./ReactUpdates"), + y = e("./Object.assign"), + g = e("./emptyObject"), + E = e("./invariant"), + C = e("./shouldUpdateReactComponent"), + b = e("./warning"), + _ = 1, + N = { + construct: function(e) { + this._currentElement = e, this._rootNodeID = null, this._instance = null, this._pendingElement = null, this._pendingStateQueue = null, this._pendingReplaceState = !1, this._pendingForceUpdate = !1, this._renderedComponent = null, this._context = null, this._mountOrder = 0, this._isTopLevel = !1, this._pendingCallbacks = null + }, + mountComponent: function(e, t, r) { + this._context = r, this._mountOrder = _++, this._rootNodeID = e; + var o = this._processProps(this._currentElement.props), + a = this._processContext(this._currentElement._context), + i = p.getComponentClassForElement(this._currentElement), + s = new i(o, a); + "production" !== n.env.NODE_ENV && ("production" !== n.env.NODE_ENV ? b(null != s.render, "%s(...): No `render` method found on the returned component instance: you may have forgotten to define `render` in your component or you may have accidentally tried to render an element whose type is a function that isn't a React component.", i.displayName || i.name || "Component") : null), s.props = o, s.context = a, s.refs = g, this._instance = s, c.set(s, this), "production" !== n.env.NODE_ENV && this._warnIfContextsDiffer(this._currentElement._context, r), "production" !== n.env.NODE_ENV && ("production" !== n.env.NODE_ENV ? b(!s.getInitialState || s.getInitialState.isReactClassApproved, "getInitialState was defined on %s, a plain JavaScript class. This is only supported for classes created using React.createClass. Did you mean to define a state property instead?", this.getName() || "a component") : null, "production" !== n.env.NODE_ENV ? b(!s.propTypes, "propTypes was defined as an instance property on %s. Use a static property to define propTypes instead.", this.getName() || "a component") : null, "production" !== n.env.NODE_ENV ? b(!s.contextTypes, "contextTypes was defined as an instance property on %s. Use a static property to define contextTypes instead.", this.getName() || "a component") : null, "production" !== n.env.NODE_ENV ? b("function" != typeof s.componentShouldUpdate, "%s has a method called componentShouldUpdate(). Did you mean shouldComponentUpdate()? The name is phrased as a question because the function is expected to return a value.", this.getName() || "A component") : null); + var u = s.state; + void 0 === u && (s.state = u = null), "production" !== n.env.NODE_ENV ? E("object" == typeof u && !Array.isArray(u), "%s.state: must be set to an object or null", this.getName() || "ReactCompositeComponent") : E("object" == typeof u && !Array.isArray(u)), this._pendingStateQueue = null, this._pendingReplaceState = !1, this._pendingForceUpdate = !1; + var d, f = l.currentlyMountingInstance; + l.currentlyMountingInstance = this; + try { + s.componentWillMount && (s.componentWillMount(), this._pendingStateQueue && (s.state = this._processPendingState(s.props, s.context))), d = this._renderValidatedComponent() + } finally { + l.currentlyMountingInstance = f + } + this._renderedComponent = this._instantiateReactComponent(d, this._currentElement.type); + var h = v.mountComponent(this._renderedComponent, e, t, this._processChildContext(r)); + return s.componentDidMount && t.getReactMountReady().enqueue(s.componentDidMount, s), h + }, + unmountComponent: function() { + var e = this._instance; + if (e.componentWillUnmount) { + var t = l.currentlyUnmountingInstance; + l.currentlyUnmountingInstance = this; + try { + e.componentWillUnmount() + } finally { + l.currentlyUnmountingInstance = t + } + } + v.unmountComponent(this._renderedComponent), this._renderedComponent = null, this._pendingStateQueue = null, this._pendingReplaceState = !1, this._pendingForceUpdate = !1, this._pendingCallbacks = null, this._pendingElement = null, this._context = null, this._rootNodeID = null, c.remove(e) + }, + _setPropsInternal: function(e, t) { + var n = this._pendingElement || this._currentElement; + this._pendingElement = s.cloneAndReplaceProps(n, y({}, n.props, e)), m.enqueueUpdate(this, t) + }, + _maskContext: function(e) { + var t = null; + if ("string" == typeof this._currentElement.type) return g; + var n = this._currentElement.type.contextTypes; + if (!n) return g; + t = {}; + for (var r in n) t[r] = e[r]; + return t + }, + _processContext: function(e) { + var t = this._maskContext(e); + if ("production" !== n.env.NODE_ENV) { + var r = p.getComponentClassForElement(this._currentElement); + r.contextTypes && this._checkPropTypes(r.contextTypes, t, f.context) + } + return t + }, + _processChildContext: function(e) { + var t = this._instance, + r = t.getChildContext && t.getChildContext(); + if (r) { + "production" !== n.env.NODE_ENV ? E("object" == typeof t.constructor.childContextTypes, "%s.getChildContext(): childContextTypes must be defined in order to use getChildContext().", this.getName() || "ReactCompositeComponent") : E("object" == typeof t.constructor.childContextTypes), "production" !== n.env.NODE_ENV && this._checkPropTypes(t.constructor.childContextTypes, r, f.childContext); + for (var o in r) "production" !== n.env.NODE_ENV ? E(o in t.constructor.childContextTypes, '%s.getChildContext(): key "%s" is not defined in childContextTypes.', this.getName() || "ReactCompositeComponent", o) : E(o in t.constructor.childContextTypes); + return y({}, e, r) + } + return e + }, + _processProps: function(e) { + if ("production" !== n.env.NODE_ENV) { + var t = p.getComponentClassForElement(this._currentElement); + t.propTypes && this._checkPropTypes(t.propTypes, e, f.prop) + } + return e + }, + _checkPropTypes: function(e, t, o) { + var a = this.getName(); + for (var i in e) + if (e.hasOwnProperty(i)) { + var s; + try { + "production" !== n.env.NODE_ENV ? E("function" == typeof e[i], "%s: %s type `%s` is invalid; it must be a function, usually from React.PropTypes.", a || "React class", h[o], i) : E("function" == typeof e[i]), s = e[i](t, i, a, o) + } catch (u) { + s = u + } + if (s instanceof Error) { + var c = r(this); + o === f.prop ? "production" !== n.env.NODE_ENV ? b(!1, "Failed Composite propType: %s%s", s.message, c) : null : "production" !== n.env.NODE_ENV ? b(!1, "Failed Context Types: %s%s", s.message, c) : null + } + } + }, + receiveComponent: function(e, t, n) { + var r = this._currentElement, + o = this._context; + this._pendingElement = null, this.updateComponent(t, r, e, o, n) + }, + performUpdateIfNecessary: function(e) { + null != this._pendingElement && v.receiveComponent(this, this._pendingElement || this._currentElement, e, this._context), (null !== this._pendingStateQueue || this._pendingForceUpdate) && ("production" !== n.env.NODE_ENV && u.checkAndWarnForMutatedProps(this._currentElement), this.updateComponent(e, this._currentElement, this._currentElement, this._context, this._context)) + }, + _warnIfContextsDiffer: function(e, t) { + e = this._maskContext(e), t = this._maskContext(t); + for (var r = Object.keys(t).sort(), o = this.getName() || "ReactCompositeComponent", a = 0; a < r.length; a++) { + var i = r[a]; + "production" !== n.env.NODE_ENV ? b(e[i] === t[i], "owner-based and parent-based contexts differ (values: `%s` vs `%s`) for key (%s) while mounting %s (see: http://fb.me/react-context-by-parent)", e[i], t[i], i, o) : null + } + }, + updateComponent: function(e, t, r, o, a) { + var i = this._instance, + s = i.context, + u = i.props; + t !== r && (s = this._processContext(r._context), u = this._processProps(r.props), "production" !== n.env.NODE_ENV && null != a && this._warnIfContextsDiffer(r._context, a), i.componentWillReceiveProps && i.componentWillReceiveProps(u, s)); + var c = this._processPendingState(u, s), + l = this._pendingForceUpdate || !i.shouldComponentUpdate || i.shouldComponentUpdate(u, c, s); + "production" !== n.env.NODE_ENV && ("production" !== n.env.NODE_ENV ? b("undefined" != typeof l, "%s.shouldComponentUpdate(): Returned undefined instead of a boolean value. Make sure to return true or false.", this.getName() || "ReactCompositeComponent") : null), l ? (this._pendingForceUpdate = !1, this._performComponentUpdate(r, u, c, s, e, a)) : (this._currentElement = r, this._context = a, i.props = u, i.state = c, i.context = s) + }, + _processPendingState: function(e, t) { + var n = this._instance, + r = this._pendingStateQueue, + o = this._pendingReplaceState; + if (this._pendingReplaceState = !1, this._pendingStateQueue = null, !r) return n.state; + for (var a = y({}, o ? r[0] : n.state), i = o ? 1 : 0; i < r.length; i++) { + var s = r[i]; + y(a, "function" == typeof s ? s.call(n, a, e, t) : s) + } + return a + }, + _performComponentUpdate: function(e, t, n, r, o, a) { + var i = this._instance, + s = i.props, + u = i.state, + c = i.context; + i.componentWillUpdate && i.componentWillUpdate(t, n, r), this._currentElement = e, this._context = a, i.props = t, i.state = n, i.context = r, this._updateRenderedComponent(o, a), i.componentDidUpdate && o.getReactMountReady().enqueue(i.componentDidUpdate.bind(i, s, u, c), i) + }, + _updateRenderedComponent: function(e, t) { + var n = this._renderedComponent, + r = n._currentElement, + o = this._renderValidatedComponent(); + if (C(r, o)) v.receiveComponent(n, o, e, this._processChildContext(t)); + else { + var a = this._rootNodeID, + i = n._rootNodeID; + v.unmountComponent(n), this._renderedComponent = this._instantiateReactComponent(o, this._currentElement.type); + var s = v.mountComponent(this._renderedComponent, a, e, t); + this._replaceNodeWithMarkupByID(i, s) + } + }, + _replaceNodeWithMarkupByID: function(e, t) { + o.replaceNodeWithMarkupByID(e, t) + }, + _renderValidatedComponentWithoutOwnerOrContext: function() { + var e = this._instance, + t = e.render(); + return "production" !== n.env.NODE_ENV && "undefined" == typeof t && e.render._isMockFunction && (t = null), t + }, + _renderValidatedComponent: function() { + var e, t = a.current; + a.current = this._processChildContext(this._currentElement._context), i.current = this; + try { + e = this._renderValidatedComponentWithoutOwnerOrContext() + } finally { + a.current = t, i.current = null + } + return "production" !== n.env.NODE_ENV ? E(null === e || e === !1 || s.isValidElement(e), "%s.render(): A valid ReactComponent must be returned. You may have returned undefined, an array or some other invalid object.", this.getName() || "ReactCompositeComponent") : E(null === e || e === !1 || s.isValidElement(e)), e + }, + attachRef: function(e, t) { + var n = this.getPublicInstance(), + r = n.refs === g ? n.refs = {} : n.refs; + r[e] = t.getPublicInstance() + }, + detachRef: function(e) { + var t = this.getPublicInstance().refs; + delete t[e] + }, + getName: function() { + var e = this._currentElement.type, + t = this._instance && this._instance.constructor; + return e.displayName || t && t.displayName || e.name || t && t.name || null + }, + getPublicInstance: function() { + return this._instance + }, + _instantiateReactComponent: null + }; + d.measureMethods(N, "ReactCompositeComponent", { + mountComponent: "mountComponent", + updateComponent: "updateComponent", + _renderValidatedComponent: "_renderValidatedComponent" + }); + var O = { + Mixin: N + }; + t.exports = O + }).call(this, e("_process")) + }, { + "./Object.assign": 35, + "./ReactComponentEnvironment": 47, + "./ReactContext": 50, + "./ReactCurrentOwner": 51, + "./ReactElement": 69, + "./ReactElementValidator": 70, + "./ReactInstanceMap": 79, + "./ReactLifeCycle": 80, + "./ReactNativeComponent": 86, + "./ReactPerf": 88, + "./ReactPropTypeLocationNames": 90, + "./ReactPropTypeLocations": 91, + "./ReactReconciler": 95, + "./ReactUpdates": 106, + "./emptyObject": 137, + "./invariant": 157, + "./shouldUpdateReactComponent": 174, + "./warning": 178, + _process: 2 + }], + 50: [function(e, t) { + (function(n) { + "use strict"; + var r = e("./Object.assign"), + o = e("./emptyObject"), + a = e("./warning"), + i = !1, + s = { + current: o, + withContext: function(e, t) { + "production" !== n.env.NODE_ENV && ("production" !== n.env.NODE_ENV ? a(i, "withContext is deprecated and will be removed in a future version. Use a wrapper component with getChildContext instead.") : null, i = !0); + var o, u = s.current; + s.current = r({}, u, e); + try { + o = t() + } finally { + s.current = u + } + return o + } + }; + t.exports = s + }).call(this, e("_process")) + }, { + "./Object.assign": 35, + "./emptyObject": 137, + "./warning": 178, + _process: 2 + }], + 51: [function(e, t) { + "use strict"; + var n = { + current: null + }; + t.exports = n + }, {}], + 52: [function(e, t) { + (function(n) { + "use strict"; + + function r(e) { + return "production" !== n.env.NODE_ENV ? a.createFactory(e) : o.createFactory(e) + } + var o = e("./ReactElement"), + a = e("./ReactElementValidator"), + i = e("./mapObject"), + s = i({ + a: "a", + abbr: "abbr", + address: "address", + area: "area", + article: "article", + aside: "aside", + audio: "audio", + b: "b", + base: "base", + bdi: "bdi", + bdo: "bdo", + big: "big", + blockquote: "blockquote", + body: "body", + br: "br", + button: "button", + canvas: "canvas", + caption: "caption", + cite: "cite", + code: "code", + col: "col", + colgroup: "colgroup", + data: "data", + datalist: "datalist", + dd: "dd", + del: "del", + details: "details", + dfn: "dfn", + dialog: "dialog", + div: "div", + dl: "dl", + dt: "dt", + em: "em", + embed: "embed", + fieldset: "fieldset", + figcaption: "figcaption", + figure: "figure", + footer: "footer", + form: "form", + h1: "h1", + h2: "h2", + h3: "h3", + h4: "h4", + h5: "h5", + h6: "h6", + head: "head", + header: "header", + hr: "hr", + html: "html", + i: "i", + iframe: "iframe", + img: "img", + input: "input", + ins: "ins", + kbd: "kbd", + keygen: "keygen", + label: "label", + legend: "legend", + li: "li", + link: "link", + main: "main", + map: "map", + mark: "mark", + menu: "menu", + menuitem: "menuitem", + meta: "meta", + meter: "meter", + nav: "nav", + noscript: "noscript", + object: "object", + ol: "ol", + optgroup: "optgroup", + option: "option", + output: "output", + p: "p", + param: "param", + picture: "picture", + pre: "pre", + progress: "progress", + q: "q", + rp: "rp", + rt: "rt", + ruby: "ruby", + s: "s", + samp: "samp", + script: "script", + section: "section", + select: "select", + small: "small", + source: "source", + span: "span", + strong: "strong", + style: "style", + sub: "sub", + summary: "summary", + sup: "sup", + table: "table", + tbody: "tbody", + td: "td", + textarea: "textarea", + tfoot: "tfoot", + th: "th", + thead: "thead", + time: "time", + title: "title", + tr: "tr", + track: "track", + u: "u", + ul: "ul", + "var": "var", + video: "video", + wbr: "wbr", + circle: "circle", + defs: "defs", + ellipse: "ellipse", + g: "g", + line: "line", + linearGradient: "linearGradient", + mask: "mask", + path: "path", + pattern: "pattern", + polygon: "polygon", + polyline: "polyline", + radialGradient: "radialGradient", + rect: "rect", + stop: "stop", + svg: "svg", + text: "text", + tspan: "tspan" + }, r); + t.exports = s + }).call(this, e("_process")) + }, { + "./ReactElement": 69, + "./ReactElementValidator": 70, + "./mapObject": 165, + _process: 2 + }], + 53: [function(e, t) { + "use strict"; + var n = e("./AutoFocusMixin"), + r = e("./ReactBrowserComponentMixin"), + o = e("./ReactClass"), + a = e("./ReactElement"), + i = e("./keyMirror"), + s = a.createFactory("button"), + u = i({ + onClick: !0, + onDoubleClick: !0, + onMouseDown: !0, + onMouseMove: !0, + onMouseUp: !0, + onClickCapture: !0, + onDoubleClickCapture: !0, + onMouseDownCapture: !0, + onMouseMoveCapture: !0, + onMouseUpCapture: !0 + }), + c = o.createClass({ + displayName: "ReactDOMButton", + tagName: "BUTTON", + mixins: [n, r], + render: function() { + var e = {}; + for (var t in this.props) !this.props.hasOwnProperty(t) || this.props.disabled && u[t] || (e[t] = this.props[t]); + return s(e, this.props.children) + } + }); + t.exports = c + }, { + "./AutoFocusMixin": 8, + "./ReactBrowserComponentMixin": 38, + "./ReactClass": 44, + "./ReactElement": 69, + "./keyMirror": 163 + }], + 54: [function(e, t) { + (function(n) { + "use strict"; + + function r(e) { + e && (null != e.dangerouslySetInnerHTML && ("production" !== n.env.NODE_ENV ? y(null == e.children, "Can only set one of `children` or `props.dangerouslySetInnerHTML`.") : y(null == e.children), "production" !== n.env.NODE_ENV ? y(null != e.dangerouslySetInnerHTML.__html, "`props.dangerouslySetInnerHTML` must be in the form `{__html: ...}`. Please visit http://fb.me/react-invariant-dangerously-set-inner-html for more information.") : y(null != e.dangerouslySetInnerHTML.__html)), "production" !== n.env.NODE_ENV && ("production" !== n.env.NODE_ENV ? C(null == e.innerHTML, "Directly setting property `innerHTML` is not permitted. For more information, lookup documentation on `dangerouslySetInnerHTML`.") : null, "production" !== n.env.NODE_ENV ? C(!e.contentEditable || null == e.children, "A component is `contentEditable` and contains `children` managed by React. It is now your responsibility to guarantee that none of those nodes are unexpectedly modified or duplicated. This is probably not intentional.") : null), "production" !== n.env.NODE_ENV ? y(null == e.style || "object" == typeof e.style, "The `style` prop expects a mapping from style properties to values, not a string. For example, style={{marginRight: spacing + 'em'}} when using JSX.") : y(null == e.style || "object" == typeof e.style)) + } + + function o(e, t, r, o) { + "production" !== n.env.NODE_ENV && ("production" !== n.env.NODE_ENV ? C("onScroll" !== t || g("scroll", !0), "This browser doesn't support the `onScroll` event") : null); + var a = d.findReactContainerForID(e); + if (a) { + var i = a.nodeType === D ? a.ownerDocument : a; + _(t, i) + } + o.getPutListenerQueue().enqueuePutListener(e, t, r) + } + + function a(e) { + P.call(T, e) || ("production" !== n.env.NODE_ENV ? y(x.test(e), "Invalid tag: %s", e) : y(x.test(e)), T[e] = !0) + } + + function i(e) { + a(e), this._tag = e, this._renderedChildren = null, this._previousStyleCopy = null, this._rootNodeID = null + } + var s = e("./CSSPropertyOperations"), + u = e("./DOMProperty"), + c = e("./DOMPropertyOperations"), + l = e("./ReactBrowserEventEmitter"), + p = e("./ReactComponentBrowserEnvironment"), + d = e("./ReactMount"), + f = e("./ReactMultiChild"), + h = e("./ReactPerf"), + v = e("./Object.assign"), + m = e("./escapeTextContentForBrowser"), + y = e("./invariant"), + g = e("./isEventSupported"), + E = e("./keyOf"), + C = e("./warning"), + b = l.deleteListener, + _ = l.listenTo, + N = l.registrationNameModules, + O = { + string: !0, + number: !0 + }, + R = E({ + style: null + }), + D = 1, + w = null, + M = { + area: !0, + base: !0, + br: !0, + col: !0, + embed: !0, + hr: !0, + img: !0, + input: !0, + keygen: !0, + link: !0, + meta: !0, + param: !0, + source: !0, + track: !0, + wbr: !0 + }, + x = /^[a-zA-Z][a-zA-Z:_\.\-\d]*$/, + T = {}, + P = {}.hasOwnProperty; + i.displayName = "ReactDOMComponent", i.Mixin = { + construct: function(e) { + this._currentElement = e + }, + mountComponent: function(e, t, n) { + this._rootNodeID = e, r(this._currentElement.props); + var o = M[this._tag] ? "" : ""; + return this._createOpenTagMarkupAndPutListeners(t) + this._createContentMarkup(t, n) + o + }, + _createOpenTagMarkupAndPutListeners: function(e) { + var t = this._currentElement.props, + n = "<" + this._tag; + for (var r in t) + if (t.hasOwnProperty(r)) { + var a = t[r]; + if (null != a) + if (N.hasOwnProperty(r)) o(this._rootNodeID, r, a, e); + else { + r === R && (a && (a = this._previousStyleCopy = v({}, t.style)), a = s.createMarkupForStyles(a)); + var i = c.createMarkupForProperty(r, a); + i && (n += " " + i) + } + } if (e.renderToStaticMarkup) return n + ">"; + var u = c.createMarkupForID(this._rootNodeID); + return n + " " + u + ">" + }, + _createContentMarkup: function(e, t) { + var n = ""; + ("listing" === this._tag || "pre" === this._tag || "textarea" === this._tag) && (n = "\n"); + var r = this._currentElement.props, + o = r.dangerouslySetInnerHTML; + if (null != o) { + if (null != o.__html) return n + o.__html + } else { + var a = O[typeof r.children] ? r.children : null, + i = null != a ? null : r.children; + if (null != a) return n + m(a); + if (null != i) { + var s = this.mountChildren(i, e, t); + return n + s.join("") + } + } + return n + }, + receiveComponent: function(e, t, n) { + var r = this._currentElement; + this._currentElement = e, this.updateComponent(t, r, e, n) + }, + updateComponent: function(e, t, n, o) { + r(this._currentElement.props), this._updateDOMProperties(t.props, e), this._updateDOMChildren(t.props, e, o) + }, + _updateDOMProperties: function(e, t) { + var n, r, a, i = this._currentElement.props; + for (n in e) + if (!i.hasOwnProperty(n) && e.hasOwnProperty(n)) + if (n === R) { + var s = this._previousStyleCopy; + for (r in s) s.hasOwnProperty(r) && (a = a || {}, a[r] = ""); + this._previousStyleCopy = null + } else N.hasOwnProperty(n) ? b(this._rootNodeID, n) : (u.isStandardName[n] || u.isCustomAttribute(n)) && w.deletePropertyByID(this._rootNodeID, n); + for (n in i) { + var c = i[n], + l = n === R ? this._previousStyleCopy : e[n]; + if (i.hasOwnProperty(n) && c !== l) + if (n === R) + if (c && (c = this._previousStyleCopy = v({}, c)), l) { + for (r in l) !l.hasOwnProperty(r) || c && c.hasOwnProperty(r) || (a = a || {}, a[r] = ""); + for (r in c) c.hasOwnProperty(r) && l[r] !== c[r] && (a = a || {}, a[r] = c[r]) + } else a = c; + else N.hasOwnProperty(n) ? o(this._rootNodeID, n, c, t) : (u.isStandardName[n] || u.isCustomAttribute(n)) && w.updatePropertyByID(this._rootNodeID, n, c) + } + a && w.updateStylesByID(this._rootNodeID, a) + }, + _updateDOMChildren: function(e, t, n) { + var r = this._currentElement.props, + o = O[typeof e.children] ? e.children : null, + a = O[typeof r.children] ? r.children : null, + i = e.dangerouslySetInnerHTML && e.dangerouslySetInnerHTML.__html, + s = r.dangerouslySetInnerHTML && r.dangerouslySetInnerHTML.__html, + u = null != o ? null : e.children, + c = null != a ? null : r.children, + l = null != o || null != i, + p = null != a || null != s; + null != u && null == c ? this.updateChildren(null, t, n) : l && !p && this.updateTextContent(""), null != a ? o !== a && this.updateTextContent("" + a) : null != s ? i !== s && w.updateInnerHTMLByID(this._rootNodeID, s) : null != c && this.updateChildren(c, t, n) + }, + unmountComponent: function() { + this.unmountChildren(), l.deleteAllListeners(this._rootNodeID), p.unmountIDFromEnvironment(this._rootNodeID), this._rootNodeID = null + } + }, h.measureMethods(i, "ReactDOMComponent", { + mountComponent: "mountComponent", + updateComponent: "updateComponent" + }), v(i.prototype, i.Mixin, f.Mixin), i.injection = { + injectIDOperations: function(e) { + i.BackendIDOperations = w = e + } + }, t.exports = i + }).call(this, e("_process")) + }, { + "./CSSPropertyOperations": 12, + "./DOMProperty": 17, + "./DOMPropertyOperations": 18, + "./Object.assign": 35, + "./ReactBrowserEventEmitter": 39, + "./ReactComponentBrowserEnvironment": 46, + "./ReactMount": 83, + "./ReactMultiChild": 84, + "./ReactPerf": 88, + "./escapeTextContentForBrowser": 138, + "./invariant": 157, + "./isEventSupported": 158, + "./keyOf": 164, + "./warning": 178, + _process: 2 + }], + 55: [function(e, t) { + "use strict"; + var n = e("./EventConstants"), + r = e("./LocalEventTrapMixin"), + o = e("./ReactBrowserComponentMixin"), + a = e("./ReactClass"), + i = e("./ReactElement"), + s = i.createFactory("form"), + u = a.createClass({ + displayName: "ReactDOMForm", + tagName: "FORM", + mixins: [o, r], + render: function() { + return s(this.props) + }, + componentDidMount: function() { + this.trapBubbledEvent(n.topLevelTypes.topReset, "reset"), this.trapBubbledEvent(n.topLevelTypes.topSubmit, "submit") + } + }); + t.exports = u + }, { + "./EventConstants": 22, + "./LocalEventTrapMixin": 33, + "./ReactBrowserComponentMixin": 38, + "./ReactClass": 44, + "./ReactElement": 69 + }], + 56: [function(e, t) { + (function(n) { + "use strict"; + var r = e("./CSSPropertyOperations"), + o = e("./DOMChildrenOperations"), + a = e("./DOMPropertyOperations"), + i = e("./ReactMount"), + s = e("./ReactPerf"), + u = e("./invariant"), + c = e("./setInnerHTML"), + l = { + dangerouslySetInnerHTML: "`dangerouslySetInnerHTML` must be set using `updateInnerHTMLByID()`.", + style: "`style` must be set using `updateStylesByID()`." + }, + p = { + updatePropertyByID: function(e, t, r) { + var o = i.getNode(e); + "production" !== n.env.NODE_ENV ? u(!l.hasOwnProperty(t), "updatePropertyByID(...): %s", l[t]) : u(!l.hasOwnProperty(t)), null != r ? a.setValueForProperty(o, t, r) : a.deleteValueForProperty(o, t) + }, + deletePropertyByID: function(e, t, r) { + var o = i.getNode(e); + "production" !== n.env.NODE_ENV ? u(!l.hasOwnProperty(t), "updatePropertyByID(...): %s", l[t]) : u(!l.hasOwnProperty(t)), a.deleteValueForProperty(o, t, r) + }, + updateStylesByID: function(e, t) { + var n = i.getNode(e); + r.setValueForStyles(n, t) + }, + updateInnerHTMLByID: function(e, t) { + var n = i.getNode(e); + c(n, t) + }, + updateTextContentByID: function(e, t) { + var n = i.getNode(e); + o.updateTextContent(n, t) + }, + dangerouslyReplaceNodeWithMarkupByID: function(e, t) { + var n = i.getNode(e); + o.dangerouslyReplaceNodeWithMarkup(n, t) + }, + dangerouslyProcessChildrenUpdates: function(e, t) { + for (var n = 0; n < e.length; n++) e[n].parentNode = i.getNode(e[n].parentID); + o.processUpdates(e, t) + } + }; + s.measureMethods(p, "ReactDOMIDOperations", { + updatePropertyByID: "updatePropertyByID", + deletePropertyByID: "deletePropertyByID", + updateStylesByID: "updateStylesByID", + updateInnerHTMLByID: "updateInnerHTMLByID", + updateTextContentByID: "updateTextContentByID", + dangerouslyReplaceNodeWithMarkupByID: "dangerouslyReplaceNodeWithMarkupByID", + dangerouslyProcessChildrenUpdates: "dangerouslyProcessChildrenUpdates" + }), t.exports = p + }).call(this, e("_process")) + }, { + "./CSSPropertyOperations": 12, + "./DOMChildrenOperations": 16, + "./DOMPropertyOperations": 18, + "./ReactMount": 83, + "./ReactPerf": 88, + "./invariant": 157, + "./setInnerHTML": 171, + _process: 2 + }], + 57: [function(e, t) { + "use strict"; + var n = e("./EventConstants"), + r = e("./LocalEventTrapMixin"), + o = e("./ReactBrowserComponentMixin"), + a = e("./ReactClass"), + i = e("./ReactElement"), + s = i.createFactory("iframe"), + u = a.createClass({ + displayName: "ReactDOMIframe", + tagName: "IFRAME", + mixins: [o, r], + render: function() { + return s(this.props) + }, + componentDidMount: function() { + this.trapBubbledEvent(n.topLevelTypes.topLoad, "load") + } + }); + t.exports = u + }, { + "./EventConstants": 22, + "./LocalEventTrapMixin": 33, + "./ReactBrowserComponentMixin": 38, + "./ReactClass": 44, + "./ReactElement": 69 + }], + 58: [function(e, t) { + "use strict"; + var n = e("./EventConstants"), + r = e("./LocalEventTrapMixin"), + o = e("./ReactBrowserComponentMixin"), + a = e("./ReactClass"), + i = e("./ReactElement"), + s = i.createFactory("img"), + u = a.createClass({ + displayName: "ReactDOMImg", + tagName: "IMG", + mixins: [o, r], + render: function() { + return s(this.props) + }, + componentDidMount: function() { + this.trapBubbledEvent(n.topLevelTypes.topLoad, "load"), this.trapBubbledEvent(n.topLevelTypes.topError, "error") + } + }); + t.exports = u + }, { + "./EventConstants": 22, + "./LocalEventTrapMixin": 33, + "./ReactBrowserComponentMixin": 38, + "./ReactClass": 44, + "./ReactElement": 69 + }], + 59: [function(e, t) { + (function(n) { + "use strict"; + + function r() { + this.isMounted() && this.forceUpdate() + } + var o = e("./AutoFocusMixin"), + a = e("./DOMPropertyOperations"), + i = e("./LinkedValueUtils"), + s = e("./ReactBrowserComponentMixin"), + u = e("./ReactClass"), + c = e("./ReactElement"), + l = e("./ReactMount"), + p = e("./ReactUpdates"), + d = e("./Object.assign"), + f = e("./invariant"), + h = c.createFactory("input"), + v = {}, + m = u.createClass({ + displayName: "ReactDOMInput", + tagName: "INPUT", + mixins: [o, i.Mixin, s], + getInitialState: function() { + var e = this.props.defaultValue; + return { + initialChecked: this.props.defaultChecked || !1, + initialValue: null != e ? e : null + } + }, + render: function() { + var e = d({}, this.props); + e.defaultChecked = null, e.defaultValue = null; + var t = i.getValue(this); + e.value = null != t ? t : this.state.initialValue; + var n = i.getChecked(this); + return e.checked = null != n ? n : this.state.initialChecked, e.onChange = this._handleChange, h(e, this.props.children) + }, + componentDidMount: function() { + var e = l.getID(this.getDOMNode()); + v[e] = this + }, + componentWillUnmount: function() { + var e = this.getDOMNode(), + t = l.getID(e); + delete v[t] + }, + componentDidUpdate: function() { + var e = this.getDOMNode(); + null != this.props.checked && a.setValueForProperty(e, "checked", this.props.checked || !1); + var t = i.getValue(this); + null != t && a.setValueForProperty(e, "value", "" + t) + }, + _handleChange: function(e) { + var t, o = i.getOnChange(this); + o && (t = o.call(this, e)), p.asap(r, this); + var a = this.props.name; + if ("radio" === this.props.type && null != a) { + for (var s = this.getDOMNode(), u = s; u.parentNode;) u = u.parentNode; + for (var c = u.querySelectorAll("input[name=" + JSON.stringify("" + a) + '][type="radio"]'), d = 0, h = c.length; h > d; d++) { + var m = c[d]; + if (m !== s && m.form === s.form) { + var y = l.getID(m); + "production" !== n.env.NODE_ENV ? f(y, "ReactDOMInput: Mixing React and non-React radio inputs with the same `name` is not supported.") : f(y); + var g = v[y]; + "production" !== n.env.NODE_ENV ? f(g, "ReactDOMInput: Unknown radio button ID %s.", y) : f(g), p.asap(r, g) + } + } + } + return t + } + }); + t.exports = m + }).call(this, e("_process")) + }, { + "./AutoFocusMixin": 8, + "./DOMPropertyOperations": 18, + "./LinkedValueUtils": 32, + "./Object.assign": 35, + "./ReactBrowserComponentMixin": 38, + "./ReactClass": 44, + "./ReactElement": 69, + "./ReactMount": 83, + "./ReactUpdates": 106, + "./invariant": 157, + _process: 2 + }], + 60: [function(e, t) { + (function(n) { + "use strict"; + var r = e("./ReactBrowserComponentMixin"), + o = e("./ReactClass"), + a = e("./ReactElement"), + i = e("./warning"), + s = a.createFactory("option"), + u = o.createClass({ + displayName: "ReactDOMOption", + tagName: "OPTION", + mixins: [r], + componentWillMount: function() { + "production" !== n.env.NODE_ENV && ("production" !== n.env.NODE_ENV ? i(null == this.props.selected, "Use the `defaultValue` or `value` props on " + r + "" + }, + receiveComponent: function(e) { + if (e !== this._currentElement) { + this._currentElement = e; + var t = "" + e; + t !== this._stringText && (this._stringText = t, o.BackendIDOperations.updateTextContentByID(this._rootNodeID, t)) + } + }, + unmountComponent: function() { + r.unmountIDFromEnvironment(this._rootNodeID) + } + }), t.exports = s + }, { + "./DOMPropertyOperations": 18, + "./Object.assign": 35, + "./ReactComponentBrowserEnvironment": 46, + "./ReactDOMComponent": 54, + "./escapeTextContentForBrowser": 138 + }], + 64: [function(e, t) { + (function(n) { + "use strict"; + + function r() { + this.isMounted() && this.forceUpdate() + } + var o = e("./AutoFocusMixin"), + a = e("./DOMPropertyOperations"), + i = e("./LinkedValueUtils"), + s = e("./ReactBrowserComponentMixin"), + u = e("./ReactClass"), + c = e("./ReactElement"), + l = e("./ReactUpdates"), + p = e("./Object.assign"), + d = e("./invariant"), + f = e("./warning"), + h = c.createFactory("textarea"), + v = u.createClass({ + displayName: "ReactDOMTextarea", + tagName: "TEXTAREA", + mixins: [o, i.Mixin, s], + getInitialState: function() { + var e = this.props.defaultValue, + t = this.props.children; + null != t && ("production" !== n.env.NODE_ENV && ("production" !== n.env.NODE_ENV ? f(!1, "Use the `defaultValue` or `value` props instead of setting children on