mirror of
https://github.com/cemu-project/DS4Windows.git
synced 2024-11-22 17:29:18 +01:00
10115 lines
421 KiB
JavaScript
10115 lines
421 KiB
JavaScript
! 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<vars.length;i++) {
|
||
var pair = vars[i].split("=");
|
||
if(pair[0] == variableName) {return decodeURIComponent(pair[1])}
|
||
}
|
||
if(variableName == "curve") return("0.00, 0.00, 1.00, 1.00");
|
||
return("")
|
||
},
|
||
d = function(e) {
|
||
function t(e) {
|
||
var n = this;
|
||
a(this, t),
|
||
r(Object.getPrototypeOf(t.prototype), "constructor", this).call(this, e),
|
||
this.state = {
|
||
value: qryVariableValue("curve").split(",").map(Number),
|
||
progress: 0
|
||
},
|
||
this.onChange = this.onChange.bind(this),
|
||
this.onChangeInputCurveDefinition = this.onChangeInputCurveDefinition.bind(this),
|
||
this.onClickExampleCurve = this.onClickExampleCurve.bind(this);
|
||
var o = function(e) {
|
||
c(o), n.setState({
|
||
progress: e / 4e3 % 1 * (document.getElementById("showProgressMovement").checked)
|
||
})
|
||
};
|
||
c(o)
|
||
}
|
||
|
||
return o(t, e), n(t, {
|
||
onChange: {
|
||
value: function(e) {
|
||
this.setState({value: e})
|
||
}
|
||
},
|
||
|
||
onChangeInputCurveDefinition: {
|
||
value: function(e) {
|
||
this.setState({value: document.getElementById("inputCurveDefinition").value.split(",").map(Number)})
|
||
}
|
||
},
|
||
|
||
onClickExampleCurve: {
|
||
value: function(e) {
|
||
document.getElementById("inputCurveDefinition").value=e.target.innerHTML.split("=")[1].trim();
|
||
this.onChangeInputCurveDefinition(e)
|
||
}
|
||
},
|
||
|
||
render: {
|
||
value: function() {
|
||
var e = this.state,
|
||
t = e.value,
|
||
n = e.progress;
|
||
return i.createElement("div", null, i.createElement("h1", null, i.createElement("a", {
|
||
href: "https://github.com/Ryochan7/DS4Windows/wiki/Settings",
|
||
style: l
|
||
}, u.name)),
|
||
i.createElement("p", {style:{"whiteSpace": "pre-wrap"}}, "(1) Grab and move around red handles in a graph to customize the bezier curve or enter specific curve values in the textbox.\n(2) When you are happy with the curve, copy-paste the EASING CURVE DEFINITION values (comma separated list of 4 numbers) to a custom LS/RS/R2/L3/SA curve output options in DS4Windows application."),
|
||
i.createElement("blockquote", null, ""),
|
||
i.createElement("input", {
|
||
id: "inputCurveDefinition",
|
||
defaultValue: qryVariableValue("curve"),
|
||
onBlur: this.onChangeInputCurveDefinition,
|
||
style: { width: "250px"},
|
||
}, ""),
|
||
i.createElement("h3", null, "easing curve definition:<3A>",
|
||
i.createElement("code", null, this.state.value.map(function(e) {
|
||
return e.toFixed(2)
|
||
}).join(", ")), i.createElement("br", null), "progress:<3A>", i.createElement("code", null, this.state.progress.toFixed(2).substring(2, 4), "%")),
|
||
|
||
i.createElement("table", null, i.createElement("tr", null,
|
||
i.createElement("td", null,
|
||
i.createElement(s, {
|
||
ref: "controlledBezierEditor",
|
||
id: "controlledBezierEditor",
|
||
value: t,
|
||
onChange: this.onChange,
|
||
style: p,
|
||
progress: n,
|
||
progressColor: "#125804",
|
||
handleStroke: 0,
|
||
handleRadius: 6,
|
||
curveWidth: 3
|
||
}, i.createElement("text", {
|
||
x: 20,
|
||
y: 16,
|
||
style: {fontWeight: "bold"}
|
||
}, "Bezier Editor"))),
|
||
i.createElement("td", null,
|
||
i.createElement("text", {style: {fontWeight: "bold"}}, "Example curves (click to choose):"), i.createElement("br", null),
|
||
i.createElement("text", {style: {cursor: "pointer"}, onClick: this.onClickExampleCurve}, "Linear = 0.00, 0.00, 1.00, 1.00"), i.createElement("br", null),
|
||
i.createElement("text", {style: {cursor: "pointer"}, onClick: this.onClickExampleCurve}, "Enhanced Precision = 0.70, 0.28, 1.00, 1.00"), i.createElement("br", null),
|
||
i.createElement("text", {style: {cursor: "pointer"}, onClick: this.onClickExampleCurve}, "Easein Quadratic = 0.55, 0.09, 0.68, 0.53"), i.createElement("br", null),
|
||
i.createElement("text", {style: {cursor: "pointer"}, onClick: this.onClickExampleCurve}, "Easein Cubic = 0.74, 0.12, 0.64, 0.29"), i.createElement("br", null),
|
||
i.createElement("text", {style: {cursor: "pointer"}, onClick: this.onClickExampleCurve}, "Easeout Quad = 0.00, 0.00, 0.41, 0.96"), i.createElement("br", null),
|
||
i.createElement("text", {style: {cursor: "pointer"}, onClick: this.onClickExampleCurve}, "Easeout Cubic = 0.08, 0.22, 0.22, 0.91"), i.createElement("br", null),
|
||
i.createElement("text", {style: {cursor: "pointer"}, onClick: this.onClickExampleCurve}, "Ease-inout = 0.42, 0.00, 0.58, 1.00"), i.createElement("br", null)
|
||
))),
|
||
|
||
i.createElement("br", null),
|
||
i.createElement("input", {
|
||
id: "showProgressMovement",
|
||
type: "checkbox",
|
||
defaultChecked: false,
|
||
value: true
|
||
}, "Show input and output movement of axis"),
|
||
i.createElement("br", null),
|
||
i.createElement("p", null, i.createElement("a", {
|
||
style: l,
|
||
target: "_blank",
|
||
href: "https://github.com/Ryochan7/DS4Windows/wiki/Settings"
|
||
}, "Click here to see DS4Windows documentation of axis curve options.")),
|
||
i.createElement("p", null, i.createElement("a", {
|
||
style: l,
|
||
target: "_blank",
|
||
href: u.homepage + "/blob/master/example/"
|
||
}, "Click here to see the source code of the original Bezier-Editor created by GRE (without DS4Windows modifications).")),
|
||
i.createElement("text", null, "Credits go to GRE who created the concept and the first sample web app. The DS4Windows customized version of the editor webapp created by MIKA-N.")
|
||
)
|
||
}
|
||
}
|
||
}), t
|
||
}(i.Component);
|
||
document.body.style.padding = "0px 20px", document.body.style.color = "#333", document.body.style.background = "#fff", document.body.style.fontFamily = "sans-serif", i.render(i.createElement(d, null), document.body)
|
||
}, {
|
||
"..": 189,
|
||
"../package.json": 182,
|
||
raf: 3,
|
||
"react/addons": 7
|
||
}],
|
||
2: [function(e, t) {
|
||
function n() {
|
||
if (!i) {
|
||
i = !0;
|
||
for (var e, t = a.length; t;) {
|
||
e = a, a = [];
|
||
for (var n = -1; ++n < t;) e[n]();
|
||
t = a.length
|
||
}
|
||
i = !1
|
||
}
|
||
}
|
||
|
||
function r() {}
|
||
var o = t.exports = {},
|
||
a = [],
|
||
i = !1;
|
||
o.nextTick = function(e) {
|
||
a.push(e), i || setTimeout(n, 0)
|
||
}, o.title = "browser", o.browser = !0, o.env = {}, o.argv = [], o.version = "", o.versions = {}, o.on = r, o.addListener = r, o.once = r, o.off = r, o.removeListener = r, o.removeAllListeners = r, o.emit = r, o.binding = function() {
|
||
throw new Error("process.binding is not supported")
|
||
}, o.cwd = function() {
|
||
return "/"
|
||
}, o.chdir = function() {
|
||
throw new Error("process.chdir is not supported")
|
||
}, o.umask = function() {
|
||
return 0
|
||
}
|
||
}, {}],
|
||
3: [function(e, t) {
|
||
for (var n = e("performance-now"), r = "undefined" == typeof window ? {} : window, o = ["moz", "webkit"], a = "AnimationFrame", i = r["request" + a], s = r["cancel" + a] || r["cancelRequest" + a], u = !0, c = 0; c < o.length && !i; c++) i = r[o[c] + "Request" + a], s = r[o[c] + "Cancel" + a] || r[o[c] + "CancelRequest" + a];
|
||
if (!i || !s) {
|
||
u = !1;
|
||
var l = 0,
|
||
p = 0,
|
||
d = [],
|
||
f = 1e3 / 60;
|
||
i = function(e) {
|
||
if (0 === d.length) {
|
||
var t = n(),
|
||
r = Math.max(0, f - (t - l));
|
||
l = r + t, setTimeout(function() {
|
||
var e = d.slice(0);
|
||
d.length = 0;
|
||
for (var t = 0; t < e.length; t++)
|
||
if (!e[t].cancelled) try {
|
||
e[t].callback(l)
|
||
} catch (n) {
|
||
setTimeout(function() {
|
||
throw n
|
||
}, 0)
|
||
}
|
||
}, Math.round(r))
|
||
}
|
||
return d.push({
|
||
handle: ++p,
|
||
callback: e,
|
||
cancelled: !1
|
||
}), p
|
||
}, s = function(e) {
|
||
for (var t = 0; t < d.length; t++) d[t].handle === e && (d[t].cancelled = !0)
|
||
}
|
||
}
|
||
t.exports = function(e) {
|
||
return u ? i.call(r, function() {
|
||
try {
|
||
e.apply(this, arguments)
|
||
} catch (t) {
|
||
setTimeout(function() {
|
||
throw t
|
||
}, 0)
|
||
}
|
||
}) : i.call(r, e)
|
||
}, t.exports.cancel = function() {
|
||
s.apply(r, arguments)
|
||
}
|
||
}, {
|
||
"performance-now": 4
|
||
}],
|
||
4: [function(e, t) {
|
||
(function(e) {
|
||
(function() {
|
||
var n, r, o;
|
||
"undefined" != typeof performance && null !== performance && performance.now ? t.exports = function() {
|
||
return performance.now()
|
||
} : "undefined" != typeof e && null !== e && e.hrtime ? (t.exports = function() {
|
||
return (n() - o) / 1e6
|
||
}, r = e.hrtime, n = function() {
|
||
var e;
|
||
return e = r(), 1e9 * e[0] + e[1]
|
||
}, o = n()) : Date.now ? (t.exports = function() {
|
||
return Date.now() - o
|
||
}, o = Date.now()) : (t.exports = function() {
|
||
return (new Date).getTime() - o
|
||
}, o = (new Date).getTime())
|
||
}).call(this)
|
||
}).call(this, e("_process"))
|
||
}, {
|
||
_process: 2
|
||
}],
|
||
5: [function(e, t, n) {
|
||
! function(e) {
|
||
"object" == typeof n ? t.exports = e() : "function" == typeof define && define.amd ? define([], e) : window.BezierEasing = e()
|
||
}(function() {
|
||
function e(e, t, c, l) {
|
||
function p(e, t) {
|
||
return 1 - 3 * t + 3 * e
|
||
}
|
||
|
||
function d(e, t) {
|
||
return 3 * t - 6 * e
|
||
}
|
||
|
||
function f(e) {
|
||
return 3 * e
|
||
}
|
||
|
||
function h(e, t, n) {
|
||
return ((p(t, n) * e + d(t, n)) * e + f(t)) * e
|
||
}
|
||
|
||
function v(e, t, n) {
|
||
return 3 * p(t, n) * e * e + 2 * d(t, n) * e + f(t)
|
||
}
|
||
|
||
function m(t, r) {
|
||
for (var o = 0; n > 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 <tbody> when using tables, nesting tags like <form>, <p>, or <a>, or using non-SVG elements in an <svg> 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 <html> 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] ? "" : "</" + 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 <select> instead of setting `selected` on <option>.") : null);
|
||
|
||
},
|
||
render: function() {
|
||
return s(this.props, this.props.children)
|
||
}
|
||
});
|
||
t.exports = u
|
||
}).call(this, e("_process"))
|
||
}, {
|
||
"./ReactBrowserComponentMixin": 38,
|
||
"./ReactClass": 44,
|
||
"./ReactElement": 69,
|
||
"./warning": 178,
|
||
_process: 2
|
||
}],
|
||
61: [function(e, t) {
|
||
"use strict";
|
||
|
||
function n() {
|
||
if (this._pendingUpdate) {
|
||
this._pendingUpdate = !1;
|
||
var e = i.getValue(this);
|
||
null != e && this.isMounted() && o(this, e)
|
||
}
|
||
}
|
||
|
||
function r(e, t) {
|
||
if (null == e[t]) return null;
|
||
if (e.multiple) {
|
||
if (!Array.isArray(e[t])) return new Error("The `" + t + "` prop supplied to <select> must be an array if `multiple` is true.")
|
||
} else if (Array.isArray(e[t])) return new Error("The `" + t + "` prop supplied to <select> must be a scalar value if `multiple` is false.")
|
||
}
|
||
|
||
function o(e, t) {
|
||
var n, r, o, a = e.getDOMNode().options;
|
||
if (e.props.multiple) {
|
||
for (n = {}, r = 0, o = t.length; o > r; r++) n["" + t[r]] = !0;
|
||
for (r = 0, o = a.length; o > r; r++) {
|
||
var i = n.hasOwnProperty(a[r].value);
|
||
a[r].selected !== i && (a[r].selected = i)
|
||
}
|
||
} else {
|
||
for (n = "" + t, r = 0, o = a.length; o > r; r++)
|
||
if (a[r].value === n) return void(a[r].selected = !0);
|
||
a.length && (a[0].selected = !0)
|
||
}
|
||
}
|
||
var a = e("./AutoFocusMixin"),
|
||
i = e("./LinkedValueUtils"),
|
||
s = e("./ReactBrowserComponentMixin"),
|
||
u = e("./ReactClass"),
|
||
c = e("./ReactElement"),
|
||
l = e("./ReactUpdates"),
|
||
p = e("./Object.assign"),
|
||
d = c.createFactory("select"),
|
||
f = u.createClass({
|
||
displayName: "ReactDOMSelect",
|
||
tagName: "SELECT",
|
||
mixins: [a, i.Mixin, s],
|
||
propTypes: {
|
||
defaultValue: r,
|
||
value: r
|
||
},
|
||
render: function() {
|
||
var e = p({}, this.props);
|
||
return e.onChange = this._handleChange, e.value = null, d(e, this.props.children)
|
||
},
|
||
componentWillMount: function() {
|
||
this._pendingUpdate = !1
|
||
},
|
||
componentDidMount: function() {
|
||
var e = i.getValue(this);
|
||
null != e ? o(this, e) : null != this.props.defaultValue && o(this, this.props.defaultValue)
|
||
},
|
||
componentDidUpdate: function(e) {
|
||
var t = i.getValue(this);
|
||
null != t ? (this._pendingUpdate = !1, o(this, t)) : !e.multiple != !this.props.multiple && (null != this.props.defaultValue ? o(this, this.props.defaultValue) : o(this, this.props.multiple ? [] : ""))
|
||
},
|
||
_handleChange: function(e) {
|
||
var t, r = i.getOnChange(this);
|
||
return r && (t = r.call(this, e)), this._pendingUpdate = !0, l.asap(n, this), t
|
||
}
|
||
});
|
||
t.exports = f
|
||
}, {
|
||
"./AutoFocusMixin": 8,
|
||
"./LinkedValueUtils": 32,
|
||
"./Object.assign": 35,
|
||
"./ReactBrowserComponentMixin": 38,
|
||
"./ReactClass": 44,
|
||
"./ReactElement": 69,
|
||
"./ReactUpdates": 106
|
||
}],
|
||
62: [function(e, t) {
|
||
"use strict";
|
||
|
||
function n(e, t, n, r) {
|
||
return e === n && t === r
|
||
}
|
||
|
||
function r(e) {
|
||
var t = document.selection,
|
||
n = t.createRange(),
|
||
r = n.text.length,
|
||
o = n.duplicate();
|
||
o.moveToElementText(e), o.setEndPoint("EndToStart", n);
|
||
var a = o.text.length,
|
||
i = a + r;
|
||
return {
|
||
start: a,
|
||
end: i
|
||
}
|
||
}
|
||
|
||
function o(e) {
|
||
var t = window.getSelection && window.getSelection();
|
||
if (!t || 0 === t.rangeCount) return null;
|
||
var r = t.anchorNode,
|
||
o = t.anchorOffset,
|
||
a = t.focusNode,
|
||
i = t.focusOffset,
|
||
s = t.getRangeAt(0),
|
||
u = n(t.anchorNode, t.anchorOffset, t.focusNode, t.focusOffset),
|
||
c = u ? 0 : s.toString().length,
|
||
l = s.cloneRange();
|
||
l.selectNodeContents(e), l.setEnd(s.startContainer, s.startOffset);
|
||
var p = n(l.startContainer, l.startOffset, l.endContainer, l.endOffset),
|
||
d = p ? 0 : l.toString().length,
|
||
f = d + c,
|
||
h = document.createRange();
|
||
h.setStart(r, o), h.setEnd(a, i);
|
||
var v = h.collapsed;
|
||
return {
|
||
start: v ? f : d,
|
||
end: v ? d : f
|
||
}
|
||
}
|
||
|
||
function a(e, t) {
|
||
var n, r, o = document.selection.createRange().duplicate();
|
||
"undefined" == typeof t.end ? (n = t.start, r = n) : t.start > t.end ? (n = t.end, r = t.start) : (n = t.start, r = t.end), o.moveToElementText(e), o.moveStart("character", n), o.setEndPoint("EndToStart", o), o.moveEnd("character", r - n), o.select()
|
||
}
|
||
|
||
function i(e, t) {
|
||
if (window.getSelection) {
|
||
var n = window.getSelection(),
|
||
r = e[c()].length,
|
||
o = Math.min(t.start, r),
|
||
a = "undefined" == typeof t.end ? o : Math.min(t.end, r);
|
||
if (!n.extend && o > a) {
|
||
var i = a;
|
||
a = o, o = i
|
||
}
|
||
var s = u(e, o),
|
||
l = u(e, a);
|
||
if (s && l) {
|
||
var p = document.createRange();
|
||
p.setStart(s.node, s.offset), n.removeAllRanges(), o > a ? (n.addRange(p), n.extend(l.node, l.offset)) : (p.setEnd(l.node, l.offset), n.addRange(p))
|
||
}
|
||
}
|
||
}
|
||
var s = e("./ExecutionEnvironment"),
|
||
u = e("./getNodeForCharacterOffset"),
|
||
c = e("./getTextContentAccessor"),
|
||
l = s.canUseDOM && "selection" in document && !("getSelection" in window),
|
||
p = {
|
||
getOffsets: l ? r : o,
|
||
setOffsets: l ? a : i
|
||
};
|
||
t.exports = p
|
||
}, {
|
||
"./ExecutionEnvironment": 28,
|
||
"./getNodeForCharacterOffset": 150,
|
||
"./getTextContentAccessor": 152
|
||
}],
|
||
63: [function(e, t) {
|
||
"use strict";
|
||
var n = e("./DOMPropertyOperations"),
|
||
r = e("./ReactComponentBrowserEnvironment"),
|
||
o = e("./ReactDOMComponent"),
|
||
a = e("./Object.assign"),
|
||
i = e("./escapeTextContentForBrowser"),
|
||
s = function() {};
|
||
a(s.prototype, {
|
||
construct: function(e) {
|
||
this._currentElement = e, this._stringText = "" + e, this._rootNodeID = null, this._mountIndex = 0
|
||
},
|
||
mountComponent: function(e, t) {
|
||
this._rootNodeID = e;
|
||
var r = i(this._stringText);
|
||
return t.renderToStaticMarkup ? r : "<span " + n.createMarkupForID(e) + ">" + r + "</span>"
|
||
},
|
||
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 <textarea>.") : null), "production" !== n.env.NODE_ENV ? d(null == e, "If you supply `defaultValue` on a <textarea>, do not pass children.") : d(null == e), Array.isArray(t) && ("production" !== n.env.NODE_ENV ? d(t.length <= 1, "<textarea> can only have at most one child.") : d(t.length <= 1), t = t[0]), e = "" + t), null == e && (e = "");
|
||
var r = i.getValue(this);
|
||
return {
|
||
initialValue: "" + (null != r ? r : e)
|
||
}
|
||
},
|
||
render: function() {
|
||
var e = p({}, this.props);
|
||
return "production" !== n.env.NODE_ENV ? d(null == e.dangerouslySetInnerHTML, "`dangerouslySetInnerHTML` does not make sense on <textarea>.") : d(null == e.dangerouslySetInnerHTML), e.defaultValue = null, e.value = null, e.onChange = this._handleChange, h(e, this.state.initialValue)
|
||
},
|
||
componentDidUpdate: function() {
|
||
var e = i.getValue(this);
|
||
if (null != e) {
|
||
var t = this.getDOMNode();
|
||
a.setValueForProperty(t, "value", "" + e)
|
||
}
|
||
},
|
||
_handleChange: function(e) {
|
||
var t, n = i.getOnChange(this);
|
||
return n && (t = n.call(this, e)), l.asap(r, this), t
|
||
}
|
||
});
|
||
t.exports = v
|
||
}).call(this, e("_process"))
|
||
}, {
|
||
"./AutoFocusMixin": 8,
|
||
"./DOMPropertyOperations": 18,
|
||
"./LinkedValueUtils": 32,
|
||
"./Object.assign": 35,
|
||
"./ReactBrowserComponentMixin": 38,
|
||
"./ReactClass": 44,
|
||
"./ReactElement": 69,
|
||
"./ReactUpdates": 106,
|
||
"./invariant": 157,
|
||
"./warning": 178,
|
||
_process: 2
|
||
}],
|
||
65: [function(e, t) {
|
||
"use strict";
|
||
|
||
function n() {
|
||
this.reinitializeTransaction()
|
||
}
|
||
var r = e("./ReactUpdates"),
|
||
o = e("./Transaction"),
|
||
a = e("./Object.assign"),
|
||
i = e("./emptyFunction"),
|
||
s = {
|
||
initialize: i,
|
||
close: function() {
|
||
p.isBatchingUpdates = !1
|
||
}
|
||
},
|
||
u = {
|
||
initialize: i,
|
||
close: r.flushBatchedUpdates.bind(r)
|
||
},
|
||
c = [u, s];
|
||
a(n.prototype, o.Mixin, {
|
||
getTransactionWrappers: function() {
|
||
return c
|
||
}
|
||
});
|
||
var l = new n,
|
||
p = {
|
||
isBatchingUpdates: !1,
|
||
batchedUpdates: function(e, t, n, r, o) {
|
||
var a = p.isBatchingUpdates;
|
||
p.isBatchingUpdates = !0, a ? e(t, n, r, o) : l.perform(e, null, t, n, r, o)
|
||
}
|
||
};
|
||
t.exports = p
|
||
}, {
|
||
"./Object.assign": 35,
|
||
"./ReactUpdates": 106,
|
||
"./Transaction": 123,
|
||
"./emptyFunction": 136
|
||
}],
|
||
66: [function(e, t) {
|
||
(function(n) {
|
||
"use strict";
|
||
|
||
function r(e) {
|
||
return h.createClass({
|
||
tagName: e.toUpperCase(),
|
||
render: function() {
|
||
return new M(e, null, null, null, null, this.props)
|
||
}
|
||
})
|
||
}
|
||
|
||
function o() {
|
||
if (T.EventEmitter.injectReactEventListener(x), T.EventPluginHub.injectEventPluginOrder(u), T.EventPluginHub.injectInstanceHandle(P), T.EventPluginHub.injectMount(I), T.EventPluginHub.injectEventPluginsByName({
|
||
SimpleEventPlugin: V,
|
||
EnterLeaveEventPlugin: c,
|
||
ChangeEventPlugin: i,
|
||
MobileSafariClickEventPlugin: d,
|
||
SelectEventPlugin: k,
|
||
BeforeInputEventPlugin: a
|
||
}), T.NativeComponent.injectGenericComponentClass(y), T.NativeComponent.injectTextComponentClass(w), T.NativeComponent.injectAutoWrapper(r), T.Class.injectMixin(f), T.NativeComponent.injectComponentClasses({
|
||
button: g,
|
||
form: E,
|
||
iframe: _,
|
||
img: C,
|
||
input: N,
|
||
option: O,
|
||
select: R,
|
||
textarea: D,
|
||
html: L("html"),
|
||
head: L("head"),
|
||
body: L("body")
|
||
}), T.DOMProperty.injectDOMPropertyConfig(p), T.DOMProperty.injectDOMPropertyConfig(U), T.EmptyComponent.injectEmptyComponent("noscript"), T.Updates.injectReconcileTransaction(S), T.Updates.injectBatchingStrategy(m), T.RootIndex.injectCreateReactRootIndex(l.canUseDOM ? s.createReactRootIndex : A.createReactRootIndex), T.Component.injectEnvironment(v), T.DOMComponent.injectIDOperations(b), "production" !== n.env.NODE_ENV) {
|
||
var t = l.canUseDOM && window.location.href || "";
|
||
if (/[?&]react_perf\b/.test(t)) {
|
||
var o = e("./ReactDefaultPerf");
|
||
o.start()
|
||
}
|
||
}
|
||
}
|
||
var a = e("./BeforeInputEventPlugin"),
|
||
i = e("./ChangeEventPlugin"),
|
||
s = e("./ClientReactRootIndex"),
|
||
u = e("./DefaultEventPluginOrder"),
|
||
c = e("./EnterLeaveEventPlugin"),
|
||
l = e("./ExecutionEnvironment"),
|
||
p = e("./HTMLDOMPropertyConfig"),
|
||
d = e("./MobileSafariClickEventPlugin"),
|
||
f = e("./ReactBrowserComponentMixin"),
|
||
h = e("./ReactClass"),
|
||
v = e("./ReactComponentBrowserEnvironment"),
|
||
m = e("./ReactDefaultBatchingStrategy"),
|
||
y = e("./ReactDOMComponent"),
|
||
g = e("./ReactDOMButton"),
|
||
E = e("./ReactDOMForm"),
|
||
C = e("./ReactDOMImg"),
|
||
b = e("./ReactDOMIDOperations"),
|
||
_ = e("./ReactDOMIframe"),
|
||
N = e("./ReactDOMInput"),
|
||
O = e("./ReactDOMOption"),
|
||
R = e("./ReactDOMSelect"),
|
||
D = e("./ReactDOMTextarea"),
|
||
w = e("./ReactDOMTextComponent"),
|
||
M = e("./ReactElement"),
|
||
x = e("./ReactEventListener"),
|
||
T = e("./ReactInjection"),
|
||
P = e("./ReactInstanceHandles"),
|
||
I = e("./ReactMount"),
|
||
S = e("./ReactReconcileTransaction"),
|
||
k = e("./SelectEventPlugin"),
|
||
A = e("./ServerReactRootIndex"),
|
||
V = e("./SimpleEventPlugin"),
|
||
U = e("./SVGDOMPropertyConfig"),
|
||
L = e("./createFullPageComponent");
|
||
t.exports = {
|
||
inject: o
|
||
}
|
||
}).call(this, e("_process"))
|
||
}, {
|
||
"./BeforeInputEventPlugin": 9,
|
||
"./ChangeEventPlugin": 14,
|
||
"./ClientReactRootIndex": 15,
|
||
"./DefaultEventPluginOrder": 20,
|
||
"./EnterLeaveEventPlugin": 21,
|
||
"./ExecutionEnvironment": 28,
|
||
"./HTMLDOMPropertyConfig": 30,
|
||
"./MobileSafariClickEventPlugin": 34,
|
||
"./ReactBrowserComponentMixin": 38,
|
||
"./ReactClass": 44,
|
||
"./ReactComponentBrowserEnvironment": 46,
|
||
"./ReactDOMButton": 53,
|
||
"./ReactDOMComponent": 54,
|
||
"./ReactDOMForm": 55,
|
||
"./ReactDOMIDOperations": 56,
|
||
"./ReactDOMIframe": 57,
|
||
"./ReactDOMImg": 58,
|
||
"./ReactDOMInput": 59,
|
||
"./ReactDOMOption": 60,
|
||
"./ReactDOMSelect": 61,
|
||
"./ReactDOMTextComponent": 63,
|
||
"./ReactDOMTextarea": 64,
|
||
"./ReactDefaultBatchingStrategy": 65,
|
||
"./ReactDefaultPerf": 67,
|
||
"./ReactElement": 69,
|
||
"./ReactEventListener": 74,
|
||
"./ReactInjection": 76,
|
||
"./ReactInstanceHandles": 78,
|
||
"./ReactMount": 83,
|
||
"./ReactReconcileTransaction": 94,
|
||
"./SVGDOMPropertyConfig": 108,
|
||
"./SelectEventPlugin": 109,
|
||
"./ServerReactRootIndex": 110,
|
||
"./SimpleEventPlugin": 111,
|
||
"./createFullPageComponent": 132,
|
||
_process: 2
|
||
}],
|
||
67: [function(e, t) {
|
||
"use strict";
|
||
|
||
function n(e) {
|
||
return Math.floor(100 * e) / 100
|
||
}
|
||
|
||
function r(e, t, n) {
|
||
e[t] = (e[t] || 0) + n
|
||
}
|
||
var o = e("./DOMProperty"),
|
||
a = e("./ReactDefaultPerfAnalysis"),
|
||
i = e("./ReactMount"),
|
||
s = e("./ReactPerf"),
|
||
u = e("./performanceNow"),
|
||
c = {
|
||
_allMeasurements: [],
|
||
_mountStack: [0],
|
||
_injected: !1,
|
||
start: function() {
|
||
c._injected || s.injection.injectMeasure(c.measure), c._allMeasurements.length = 0, s.enableMeasure = !0
|
||
},
|
||
stop: function() {
|
||
s.enableMeasure = !1
|
||
},
|
||
getLastMeasurements: function() {
|
||
return c._allMeasurements
|
||
},
|
||
printExclusive: function(e) {
|
||
e = e || c._allMeasurements;
|
||
var t = a.getExclusiveSummary(e);
|
||
console.table(t.map(function(e) {
|
||
return {
|
||
"Component class name": e.componentName,
|
||
"Total inclusive time (ms)": n(e.inclusive),
|
||
"Exclusive mount time (ms)": n(e.exclusive),
|
||
"Exclusive render time (ms)": n(e.render),
|
||
"Mount time per instance (ms)": n(e.exclusive / e.count),
|
||
"Render time per instance (ms)": n(e.render / e.count),
|
||
Instances: e.count
|
||
}
|
||
}))
|
||
},
|
||
printInclusive: function(e) {
|
||
e = e || c._allMeasurements;
|
||
var t = a.getInclusiveSummary(e);
|
||
console.table(t.map(function(e) {
|
||
return {
|
||
"Owner > component": e.componentName,
|
||
"Inclusive time (ms)": n(e.time),
|
||
Instances: e.count
|
||
}
|
||
})), console.log("Total time:", a.getTotalTime(e).toFixed(2) + " ms")
|
||
},
|
||
getMeasurementsSummaryMap: function(e) {
|
||
var t = a.getInclusiveSummary(e, !0);
|
||
return t.map(function(e) {
|
||
return {
|
||
"Owner > component": e.componentName,
|
||
"Wasted time (ms)": e.time,
|
||
Instances: e.count
|
||
}
|
||
})
|
||
},
|
||
printWasted: function(e) {
|
||
e = e || c._allMeasurements, console.table(c.getMeasurementsSummaryMap(e)), console.log("Total time:", a.getTotalTime(e).toFixed(2) + " ms")
|
||
},
|
||
printDOM: function(e) {
|
||
e = e || c._allMeasurements;
|
||
var t = a.getDOMSummary(e);
|
||
console.table(t.map(function(e) {
|
||
var t = {};
|
||
return t[o.ID_ATTRIBUTE_NAME] = e.id, t.type = e.type, t.args = JSON.stringify(e.args), t
|
||
})), console.log("Total time:", a.getTotalTime(e).toFixed(2) + " ms")
|
||
},
|
||
_recordWrite: function(e, t, n, r) {
|
||
var o = c._allMeasurements[c._allMeasurements.length - 1].writes;
|
||
o[e] = o[e] || [], o[e].push({
|
||
type: t,
|
||
time: n,
|
||
args: r
|
||
})
|
||
},
|
||
measure: function(e, t, n) {
|
||
return function() {
|
||
for (var o = [], a = 0, s = arguments.length; s > a; a++) o.push(arguments[a]);
|
||
var l, p, d;
|
||
if ("_renderNewRootComponent" === t || "flushBatchedUpdates" === t) return c._allMeasurements.push({
|
||
exclusive: {},
|
||
inclusive: {},
|
||
render: {},
|
||
counts: {},
|
||
writes: {},
|
||
displayNames: {},
|
||
totalTime: 0
|
||
}), d = u(), p = n.apply(this, o), c._allMeasurements[c._allMeasurements.length - 1].totalTime = u() - d, p;
|
||
if ("_mountImageIntoNode" === t || "ReactDOMIDOperations" === e) {
|
||
if (d = u(), p = n.apply(this, o), l = u() - d, "_mountImageIntoNode" === t) {
|
||
var f = i.getID(o[1]);
|
||
c._recordWrite(f, t, l, o[0])
|
||
} else "dangerouslyProcessChildrenUpdates" === t ? o[0].forEach(function(e) {
|
||
var t = {};
|
||
null !== e.fromIndex && (t.fromIndex = e.fromIndex), null !== e.toIndex && (t.toIndex = e.toIndex), null !== e.textContent && (t.textContent = e.textContent), null !== e.markupIndex && (t.markup = o[1][e.markupIndex]), c._recordWrite(e.parentID, e.type, l, t)
|
||
}) : c._recordWrite(o[0], t, l, Array.prototype.slice.call(o, 1));
|
||
return p
|
||
}
|
||
if ("ReactCompositeComponent" !== e || "mountComponent" !== t && "updateComponent" !== t && "_renderValidatedComponent" !== t) return n.apply(this, o);
|
||
if ("string" == typeof this._currentElement.type) return n.apply(this, o);
|
||
var h = "mountComponent" === t ? o[0] : this._rootNodeID,
|
||
v = "_renderValidatedComponent" === t,
|
||
m = "mountComponent" === t,
|
||
y = c._mountStack,
|
||
g = c._allMeasurements[c._allMeasurements.length - 1];
|
||
if (v ? r(g.counts, h, 1) : m && y.push(0), d = u(), p = n.apply(this, o), l = u() - d, v) r(g.render, h, l);
|
||
else if (m) {
|
||
var E = y.pop();
|
||
y[y.length - 1] += l, r(g.exclusive, h, l - E), r(g.inclusive, h, l)
|
||
} else r(g.inclusive, h, l);
|
||
return g.displayNames[h] = {
|
||
current: this.getName(),
|
||
owner: this._currentElement._owner ? this._currentElement._owner.getName() : "<root>"
|
||
}, p
|
||
}
|
||
}
|
||
};
|
||
t.exports = c
|
||
}, {
|
||
"./DOMProperty": 17,
|
||
"./ReactDefaultPerfAnalysis": 68,
|
||
"./ReactMount": 83,
|
||
"./ReactPerf": 88,
|
||
"./performanceNow": 169
|
||
}],
|
||
68: [function(e, t) {
|
||
function n(e) {
|
||
for (var t = 0, n = 0; n < e.length; n++) {
|
||
var r = e[n];
|
||
t += r.totalTime
|
||
}
|
||
return t
|
||
}
|
||
|
||
function r(e) {
|
||
for (var t = [], n = 0; n < e.length; n++) {
|
||
var r, o = e[n];
|
||
for (r in o.writes) o.writes[r].forEach(function(e) {
|
||
t.push({
|
||
id: r,
|
||
type: c[e.type] || e.type,
|
||
args: e.args
|
||
})
|
||
})
|
||
}
|
||
return t
|
||
}
|
||
|
||
function o(e) {
|
||
for (var t, n = {}, r = 0; r < e.length; r++) {
|
||
var o = e[r],
|
||
a = s({}, o.exclusive, o.inclusive);
|
||
for (var i in a) t = o.displayNames[i].current, n[t] = n[t] || {
|
||
componentName: t,
|
||
inclusive: 0,
|
||
exclusive: 0,
|
||
render: 0,
|
||
count: 0
|
||
}, o.render[i] && (n[t].render += o.render[i]), o.exclusive[i] && (n[t].exclusive += o.exclusive[i]), o.inclusive[i] && (n[t].inclusive += o.inclusive[i]), o.counts[i] && (n[t].count += o.counts[i])
|
||
}
|
||
var c = [];
|
||
for (t in n) n[t].exclusive >= u && c.push(n[t]);
|
||
return c.sort(function(e, t) {
|
||
return t.exclusive - e.exclusive
|
||
}), c
|
||
}
|
||
|
||
function a(e, t) {
|
||
for (var n, r = {}, o = 0; o < e.length; o++) {
|
||
var a, c = e[o],
|
||
l = s({}, c.exclusive, c.inclusive);
|
||
t && (a = i(c));
|
||
for (var p in l)
|
||
if (!t || a[p]) {
|
||
var d = c.displayNames[p];
|
||
n = d.owner + " > " + d.current, r[n] = r[n] || {
|
||
componentName: n,
|
||
time: 0,
|
||
count: 0
|
||
}, c.inclusive[p] && (r[n].time += c.inclusive[p]), c.counts[p] && (r[n].count += c.counts[p])
|
||
}
|
||
}
|
||
var f = [];
|
||
for (n in r) r[n].time >= u && f.push(r[n]);
|
||
return f.sort(function(e, t) {
|
||
return t.time - e.time
|
||
}), f
|
||
}
|
||
|
||
function i(e) {
|
||
var t = {},
|
||
n = Object.keys(e.writes),
|
||
r = s({}, e.exclusive, e.inclusive);
|
||
for (var o in r) {
|
||
for (var a = !1, i = 0; i < n.length; i++)
|
||
if (0 === n[i].indexOf(o)) {
|
||
a = !0;
|
||
break
|
||
}! a && e.counts[o] > 0 && (t[o] = !0)
|
||
}
|
||
return t
|
||
}
|
||
var s = e("./Object.assign"),
|
||
u = 1.2,
|
||
c = {
|
||
_mountImageIntoNode: "set innerHTML",
|
||
INSERT_MARKUP: "set innerHTML",
|
||
MOVE_EXISTING: "move",
|
||
REMOVE_NODE: "remove",
|
||
TEXT_CONTENT: "set textContent",
|
||
updatePropertyByID: "update attribute",
|
||
deletePropertyByID: "delete attribute",
|
||
updateStylesByID: "update styles",
|
||
updateInnerHTMLByID: "set innerHTML",
|
||
dangerouslyReplaceNodeWithMarkupByID: "replace"
|
||
},
|
||
l = {
|
||
getExclusiveSummary: o,
|
||
getInclusiveSummary: a,
|
||
getDOMSummary: r,
|
||
getTotalTime: n
|
||
};
|
||
t.exports = l
|
||
}, {
|
||
"./Object.assign": 35
|
||
}],
|
||
69: [function(e, t) {
|
||
(function(n) {
|
||
"use strict";
|
||
|
||
function r(e, t) {
|
||
Object.defineProperty(e, t, {
|
||
configurable: !1,
|
||
enumerable: !0,
|
||
get: function() {
|
||
return this._store ? this._store[t] : null
|
||
},
|
||
set: function(e) {
|
||
"production" !== n.env.NODE_ENV ? u(!1, "Don't set the %s property of the React element. Instead, specify the correct value when initially creating the element.", t) : null, this._store[t] = e
|
||
}
|
||
})
|
||
}
|
||
|
||
function o(e) {
|
||
try {
|
||
var t = {
|
||
props: !0
|
||
};
|
||
for (var n in t) r(e, n);
|
||
l = !0
|
||
} catch (o) {}
|
||
}
|
||
var a = e("./ReactContext"),
|
||
i = e("./ReactCurrentOwner"),
|
||
s = e("./Object.assign"),
|
||
u = e("./warning"),
|
||
c = {
|
||
key: !0,
|
||
ref: !0
|
||
},
|
||
l = !1,
|
||
p = function(e, t, r, o, a, i) {
|
||
if (this.type = e, this.key = t, this.ref = r, this._owner = o, this._context = a, "production" !== n.env.NODE_ENV) {
|
||
this._store = {
|
||
props: i,
|
||
originalProps: s({}, i)
|
||
};
|
||
try {
|
||
Object.defineProperty(this._store, "validated", {
|
||
configurable: !1,
|
||
enumerable: !1,
|
||
writable: !0
|
||
})
|
||
} catch (u) {}
|
||
if (this._store.validated = !1, l) return void Object.freeze(this)
|
||
}
|
||
this.props = i
|
||
};
|
||
p.prototype = {
|
||
_isReactElement: !0
|
||
}, "production" !== n.env.NODE_ENV && o(p.prototype), p.createElement = function(e, t, n) {
|
||
var r, o = {},
|
||
s = null,
|
||
u = null;
|
||
if (null != t) {
|
||
u = void 0 === t.ref ? null : t.ref, s = void 0 === t.key ? null : "" + t.key;
|
||
for (r in t) t.hasOwnProperty(r) && !c.hasOwnProperty(r) && (o[r] = t[r])
|
||
}
|
||
var l = arguments.length - 2;
|
||
if (1 === l) o.children = n;
|
||
else if (l > 1) {
|
||
for (var d = Array(l), f = 0; l > f; f++) d[f] = arguments[f + 2];
|
||
o.children = d
|
||
}
|
||
if (e && e.defaultProps) {
|
||
var h = e.defaultProps;
|
||
for (r in h) "undefined" == typeof o[r] && (o[r] = h[r])
|
||
}
|
||
return new p(e, s, u, i.current, a.current, o)
|
||
}, p.createFactory = function(e) {
|
||
var t = p.createElement.bind(null, e);
|
||
return t.type = e, t
|
||
}, p.cloneAndReplaceProps = function(e, t) {
|
||
var r = new p(e.type, e.key, e.ref, e._owner, e._context, t);
|
||
return "production" !== n.env.NODE_ENV && (r._store.validated = e._store.validated), r
|
||
}, p.cloneElement = function(e, t, n) {
|
||
var r, o = s({}, e.props),
|
||
a = e.key,
|
||
u = e.ref,
|
||
l = e._owner;
|
||
if (null != t) {
|
||
void 0 !== t.ref && (u = t.ref, l = i.current), void 0 !== t.key && (a = "" + t.key);
|
||
for (r in t) t.hasOwnProperty(r) && !c.hasOwnProperty(r) && (o[r] = t[r])
|
||
}
|
||
var d = arguments.length - 2;
|
||
if (1 === d) o.children = n;
|
||
else if (d > 1) {
|
||
for (var f = Array(d), h = 0; d > h; h++) f[h] = arguments[h + 2];
|
||
o.children = f
|
||
}
|
||
return new p(e.type, a, u, l, e._context, o)
|
||
}, p.isValidElement = function(e) {
|
||
var t = !(!e || !e._isReactElement);
|
||
return t
|
||
}, t.exports = p
|
||
}).call(this, e("_process"))
|
||
}, {
|
||
"./Object.assign": 35,
|
||
"./ReactContext": 50,
|
||
"./ReactCurrentOwner": 51,
|
||
"./warning": 178,
|
||
_process: 2
|
||
}],
|
||
70: [function(e, t) {
|
||
(function(n) {
|
||
"use strict";
|
||
|
||
function r() {
|
||
if (E.current) {
|
||
var e = E.current.getName();
|
||
if (e) return " Check the render method of `" + e + "`."
|
||
}
|
||
return ""
|
||
}
|
||
|
||
function o(e) {
|
||
var t = e && e.getPublicInstance();
|
||
if (!t) return void 0;
|
||
var n = t.constructor;
|
||
return n ? n.displayName || n.name || void 0 : void 0
|
||
}
|
||
|
||
function a() {
|
||
var e = E.current;
|
||
return e && o(e) || void 0
|
||
}
|
||
|
||
function i(e, t) {
|
||
e._store.validated || null != e.key || (e._store.validated = !0, u('Each child in an array or iterator should have a unique "key" prop.', e, t))
|
||
}
|
||
|
||
function s(e, t, n) {
|
||
D.test(e) && u("Child objects should have non-numeric keys so ordering is preserved.", t, n)
|
||
}
|
||
|
||
function u(e, t, r) {
|
||
var i = a(),
|
||
s = "string" == typeof r ? r : r.displayName || r.name,
|
||
u = i || s,
|
||
c = O[e] || (O[e] = {});
|
||
if (!c.hasOwnProperty(u)) {
|
||
c[u] = !0;
|
||
var l = i ? " Check the render method of " + i + "." : s ? " Check the React.render call using <" + s + ">." : "",
|
||
p = "";
|
||
if (t && t._owner && t._owner !== E.current) {
|
||
var d = o(t._owner);
|
||
p = " It was passed a child from " + d + "."
|
||
}
|
||
"production" !== n.env.NODE_ENV ? N(!1, e + "%s%s See http://fb.me/react-warning-keys for more information.", l, p) : null
|
||
}
|
||
}
|
||
|
||
function c(e, t) {
|
||
if (Array.isArray(e))
|
||
for (var n = 0; n < e.length; n++) {
|
||
var r = e[n];
|
||
v.isValidElement(r) && i(r, t)
|
||
} else if (v.isValidElement(e)) e._store.validated = !0;
|
||
else if (e) {
|
||
var o = b(e);
|
||
if (o) {
|
||
if (o !== e.entries)
|
||
for (var a, u = o.call(e); !(a = u.next()).done;) v.isValidElement(a.value) && i(a.value, t)
|
||
} else if ("object" == typeof e) {
|
||
var c = m.extractIfFragment(e);
|
||
for (var l in c) c.hasOwnProperty(l) && s(l, c[l], t)
|
||
}
|
||
}
|
||
}
|
||
|
||
function l(e, t, o, a) {
|
||
for (var i in t)
|
||
if (t.hasOwnProperty(i)) {
|
||
var s;
|
||
try {
|
||
"production" !== n.env.NODE_ENV ? _("function" == typeof t[i], "%s: %s type `%s` is invalid; it must be a function, usually from React.PropTypes.", e || "React class", g[a], i) : _("function" == typeof t[i]), s = t[i](o, i, e, a)
|
||
} catch (u) {
|
||
s = u
|
||
}
|
||
if (s instanceof Error && !(s.message in R)) {
|
||
R[s.message] = !0;
|
||
var c = r(this);
|
||
"production" !== n.env.NODE_ENV ? N(!1, "Failed propType: %s%s", s.message, c) : null
|
||
}
|
||
}
|
||
}
|
||
|
||
function p(e, t) {
|
||
var r = t.type,
|
||
o = "string" == typeof r ? r : r.displayName,
|
||
a = t._owner ? t._owner.getPublicInstance().constructor.displayName : null,
|
||
i = e + "|" + o + "|" + a;
|
||
if (!w.hasOwnProperty(i)) {
|
||
w[i] = !0;
|
||
var s = "";
|
||
o && (s = " <" + o + " />");
|
||
var u = "";
|
||
a && (u = " The element was created by " + a + "."), "production" !== n.env.NODE_ENV ? N(!1, "Don't set .props.%s of the React component%s. Instead, specify the correct value when initially creating the element.%s", e, s, u) : null
|
||
}
|
||
}
|
||
|
||
function d(e, t) {
|
||
return e !== e ? t !== t : 0 === e && 0 === t ? 1 / e === 1 / t : e === t
|
||
}
|
||
|
||
function f(e) {
|
||
if (e._store) {
|
||
var t = e._store.originalProps,
|
||
n = e.props;
|
||
for (var r in n) n.hasOwnProperty(r) && (t.hasOwnProperty(r) && d(t[r], n[r]) || (p(r, e), t[r] = n[r]))
|
||
}
|
||
}
|
||
|
||
function h(e) {
|
||
if (null != e.type) {
|
||
var t = C.getComponentClassForElement(e),
|
||
r = t.displayName || t.name;
|
||
t.propTypes && l(r, t.propTypes, e.props, y.prop), "function" == typeof t.getDefaultProps && ("production" !== n.env.NODE_ENV ? N(t.getDefaultProps.isReactClassApproved, "getDefaultProps is only used on classic React.createClass definitions. Use a static property named `defaultProps` instead.") : null)
|
||
}
|
||
}
|
||
var v = e("./ReactElement"),
|
||
m = e("./ReactFragment"),
|
||
y = e("./ReactPropTypeLocations"),
|
||
g = e("./ReactPropTypeLocationNames"),
|
||
E = e("./ReactCurrentOwner"),
|
||
C = e("./ReactNativeComponent"),
|
||
b = e("./getIteratorFn"),
|
||
_ = e("./invariant"),
|
||
N = e("./warning"),
|
||
O = {},
|
||
R = {},
|
||
D = /^\d+$/,
|
||
w = {},
|
||
M = {
|
||
checkAndWarnForMutatedProps: f,
|
||
createElement: function(e) {
|
||
"production" !== n.env.NODE_ENV ? N(null != e, "React.createElement: type should not be null or undefined. It should be a string (for DOM elements) or a ReactClass (for composite components).") : null;
|
||
var t = v.createElement.apply(this, arguments);
|
||
if (null == t) return t;
|
||
for (var r = 2; r < arguments.length; r++) c(arguments[r], e);
|
||
return h(t), t
|
||
},
|
||
createFactory: function(e) {
|
||
var t = M.createElement.bind(null, e);
|
||
if (t.type = e, "production" !== n.env.NODE_ENV) try {
|
||
Object.defineProperty(t, "type", {
|
||
enumerable: !1,
|
||
get: function() {
|
||
return "production" !== n.env.NODE_ENV ? N(!1, "Factory.type is deprecated. Access the class directly before passing it to createFactory.") : null, Object.defineProperty(this, "type", {
|
||
value: e
|
||
}), e
|
||
}
|
||
})
|
||
} catch (r) {}
|
||
return t
|
||
},
|
||
cloneElement: function() {
|
||
for (var e = v.cloneElement.apply(this, arguments), t = 2; t < arguments.length; t++) c(arguments[t], e.type);
|
||
return h(e), e
|
||
}
|
||
};
|
||
t.exports = M
|
||
}).call(this, e("_process"))
|
||
}, {
|
||
"./ReactCurrentOwner": 51,
|
||
"./ReactElement": 69,
|
||
"./ReactFragment": 75,
|
||
"./ReactNativeComponent": 86,
|
||
"./ReactPropTypeLocationNames": 90,
|
||
"./ReactPropTypeLocations": 91,
|
||
"./getIteratorFn": 148,
|
||
"./invariant": 157,
|
||
"./warning": 178,
|
||
_process: 2
|
||
}],
|
||
71: [function(e, t) {
|
||
(function(n) {
|
||
"use strict";
|
||
|
||
function r(e) {
|
||
l[e] = !0
|
||
}
|
||
|
||
function o(e) {
|
||
delete l[e]
|
||
}
|
||
|
||
function a(e) {
|
||
return !!l[e]
|
||
}
|
||
var i, s = e("./ReactElement"),
|
||
u = e("./ReactInstanceMap"),
|
||
c = e("./invariant"),
|
||
l = {},
|
||
p = {
|
||
injectEmptyComponent: function(e) {
|
||
i = s.createFactory(e)
|
||
}
|
||
},
|
||
d = function() {};
|
||
d.prototype.componentDidMount = function() {
|
||
var e = u.get(this);
|
||
e && r(e._rootNodeID)
|
||
}, d.prototype.componentWillUnmount = function() {
|
||
var e = u.get(this);
|
||
e && o(e._rootNodeID)
|
||
}, d.prototype.render = function() {
|
||
return "production" !== n.env.NODE_ENV ? c(i, "Trying to return null from a render, but no null placeholder component was injected.") : c(i), i()
|
||
};
|
||
var f = s.createElement(d),
|
||
h = {
|
||
emptyElement: f,
|
||
injection: p,
|
||
isNullComponentID: a
|
||
};
|
||
t.exports = h
|
||
}).call(this, e("_process"))
|
||
}, {
|
||
"./ReactElement": 69,
|
||
"./ReactInstanceMap": 79,
|
||
"./invariant": 157,
|
||
_process: 2
|
||
}],
|
||
72: [function(e, t) {
|
||
"use strict";
|
||
var n = {
|
||
guard: function(e) {
|
||
return e
|
||
}
|
||
};
|
||
t.exports = n
|
||
}, {}],
|
||
73: [function(e, t) {
|
||
"use strict";
|
||
|
||
function n(e) {
|
||
r.enqueueEvents(e), r.processEventQueue()
|
||
}
|
||
var r = e("./EventPluginHub"),
|
||
o = {
|
||
handleTopLevel: function(e, t, o, a) {
|
||
var i = r.extractEvents(e, t, o, a);
|
||
n(i)
|
||
}
|
||
};
|
||
t.exports = o
|
||
}, {
|
||
"./EventPluginHub": 24
|
||
}],
|
||
74: [function(e, t) {
|
||
"use strict";
|
||
|
||
function n(e) {
|
||
var t = l.getID(e),
|
||
n = c.getReactRootIDFromNodeID(t),
|
||
r = l.findReactContainerForID(n),
|
||
o = l.getFirstReactDOM(r);
|
||
return o
|
||
}
|
||
|
||
function r(e, t) {
|
||
this.topLevelType = e, this.nativeEvent = t, this.ancestors = []
|
||
}
|
||
|
||
function o(e) {
|
||
for (var t = l.getFirstReactDOM(f(e.nativeEvent)) || window, r = t; r;) e.ancestors.push(r), r = n(r);
|
||
for (var o = 0, a = e.ancestors.length; a > o; o++) {
|
||
t = e.ancestors[o];
|
||
var i = l.getID(t) || "";
|
||
v._handleTopLevel(e.topLevelType, t, i, e.nativeEvent)
|
||
}
|
||
}
|
||
|
||
function a(e) {
|
||
var t = h(window);
|
||
e(t)
|
||
}
|
||
var i = e("./EventListener"),
|
||
s = e("./ExecutionEnvironment"),
|
||
u = e("./PooledClass"),
|
||
c = e("./ReactInstanceHandles"),
|
||
l = e("./ReactMount"),
|
||
p = e("./ReactUpdates"),
|
||
d = e("./Object.assign"),
|
||
f = e("./getEventTarget"),
|
||
h = e("./getUnboundedScrollPosition");
|
||
d(r.prototype, {
|
||
destructor: function() {
|
||
this.topLevelType = null, this.nativeEvent = null, this.ancestors.length = 0
|
||
}
|
||
}), u.addPoolingTo(r, u.twoArgumentPooler);
|
||
var v = {
|
||
_enabled: !0,
|
||
_handleTopLevel: null,
|
||
WINDOW_HANDLE: s.canUseDOM ? window : null,
|
||
setHandleTopLevel: function(e) {
|
||
v._handleTopLevel = e
|
||
},
|
||
setEnabled: function(e) {
|
||
v._enabled = !!e
|
||
},
|
||
isEnabled: function() {
|
||
return v._enabled
|
||
},
|
||
trapBubbledEvent: function(e, t, n) {
|
||
var r = n;
|
||
return r ? i.listen(r, t, v.dispatchEvent.bind(null, e)) : null
|
||
},
|
||
trapCapturedEvent: function(e, t, n) {
|
||
var r = n;
|
||
return r ? i.capture(r, t, v.dispatchEvent.bind(null, e)) : null
|
||
},
|
||
monitorScrollValue: function(e) {
|
||
var t = a.bind(null, e);
|
||
i.listen(window, "scroll", t)
|
||
},
|
||
dispatchEvent: function(e, t) {
|
||
if (v._enabled) {
|
||
var n = r.getPooled(e, t);
|
||
try {
|
||
p.batchedUpdates(o, n)
|
||
} finally {
|
||
r.release(n)
|
||
}
|
||
}
|
||
}
|
||
};
|
||
t.exports = v
|
||
}, {
|
||
"./EventListener": 23,
|
||
"./ExecutionEnvironment": 28,
|
||
"./Object.assign": 35,
|
||
"./PooledClass": 36,
|
||
"./ReactInstanceHandles": 78,
|
||
"./ReactMount": 83,
|
||
"./ReactUpdates": 106,
|
||
"./getEventTarget": 147,
|
||
"./getUnboundedScrollPosition": 153
|
||
}],
|
||
75: [function(e, t) {
|
||
(function(n) {
|
||
"use strict";
|
||
var r = e("./ReactElement"),
|
||
o = e("./warning");
|
||
if ("production" !== n.env.NODE_ENV) {
|
||
var a = "_reactFragment",
|
||
i = "_reactDidWarn",
|
||
s = !1;
|
||
try {
|
||
var u = function() {
|
||
return 1
|
||
};
|
||
Object.defineProperty({}, a, {
|
||
enumerable: !1,
|
||
value: !0
|
||
}), Object.defineProperty({}, "key", {
|
||
enumerable: !0,
|
||
get: u
|
||
}), s = !0
|
||
} catch (c) {}
|
||
var l = function(e, t) {
|
||
Object.defineProperty(e, t, {
|
||
enumerable: !0,
|
||
get: function() {
|
||
return "production" !== n.env.NODE_ENV ? o(this[i], "A ReactFragment is an opaque type. Accessing any of its properties is deprecated. Pass it to one of the React.Children helpers.") : null, this[i] = !0, this[a][t]
|
||
},
|
||
set: function(e) {
|
||
"production" !== n.env.NODE_ENV ? o(this[i], "A ReactFragment is an immutable opaque type. Mutating its properties is deprecated.") : null, this[i] = !0, this[a][t] = e
|
||
}
|
||
})
|
||
},
|
||
p = {},
|
||
d = function(e) {
|
||
var t = "";
|
||
for (var n in e) t += n + ":" + typeof e[n] + ",";
|
||
var r = !!p[t];
|
||
return p[t] = !0, r
|
||
}
|
||
}
|
||
var f = {
|
||
create: function(e) {
|
||
if ("production" !== n.env.NODE_ENV) {
|
||
if ("object" != typeof e || !e || Array.isArray(e)) return "production" !== n.env.NODE_ENV ? o(!1, "React.addons.createFragment only accepts a single object.", e) : null, e;
|
||
if (r.isValidElement(e)) return "production" !== n.env.NODE_ENV ? o(!1, "React.addons.createFragment does not accept a ReactElement without a wrapper object.") : null, e;
|
||
if (s) {
|
||
var t = {};
|
||
Object.defineProperty(t, a, {
|
||
enumerable: !1,
|
||
value: e
|
||
}), Object.defineProperty(t, i, {
|
||
writable: !0,
|
||
enumerable: !1,
|
||
value: !1
|
||
});
|
||
for (var u in e) l(t, u);
|
||
return Object.preventExtensions(t), t
|
||
}
|
||
}
|
||
return e
|
||
},
|
||
extract: function(e) {
|
||
return "production" !== n.env.NODE_ENV && s ? e[a] ? e[a] : ("production" !== n.env.NODE_ENV ? o(d(e), "Any use of a keyed object should be wrapped in React.addons.createFragment(object) before being passed as a child.") : null, e) : e
|
||
},
|
||
extractIfFragment: function(e) {
|
||
if ("production" !== n.env.NODE_ENV && s) {
|
||
if (e[a]) return e[a];
|
||
for (var t in e)
|
||
if (e.hasOwnProperty(t) && r.isValidElement(e[t])) return f.extract(e)
|
||
}
|
||
return e
|
||
}
|
||
};
|
||
t.exports = f
|
||
}).call(this, e("_process"))
|
||
}, {
|
||
"./ReactElement": 69,
|
||
"./warning": 178,
|
||
_process: 2
|
||
}],
|
||
76: [function(e, t) {
|
||
"use strict";
|
||
var n = e("./DOMProperty"),
|
||
r = e("./EventPluginHub"),
|
||
o = e("./ReactComponentEnvironment"),
|
||
a = e("./ReactClass"),
|
||
i = e("./ReactEmptyComponent"),
|
||
s = e("./ReactBrowserEventEmitter"),
|
||
u = e("./ReactNativeComponent"),
|
||
c = e("./ReactDOMComponent"),
|
||
l = e("./ReactPerf"),
|
||
p = e("./ReactRootIndex"),
|
||
d = e("./ReactUpdates"),
|
||
f = {
|
||
Component: o.injection,
|
||
Class: a.injection,
|
||
DOMComponent: c.injection,
|
||
DOMProperty: n.injection,
|
||
EmptyComponent: i.injection,
|
||
EventPluginHub: r.injection,
|
||
EventEmitter: s.injection,
|
||
NativeComponent: u.injection,
|
||
Perf: l.injection,
|
||
RootIndex: p.injection,
|
||
Updates: d.injection
|
||
};
|
||
t.exports = f
|
||
}, {
|
||
"./DOMProperty": 17,
|
||
"./EventPluginHub": 24,
|
||
"./ReactBrowserEventEmitter": 39,
|
||
"./ReactClass": 44,
|
||
"./ReactComponentEnvironment": 47,
|
||
"./ReactDOMComponent": 54,
|
||
"./ReactEmptyComponent": 71,
|
||
"./ReactNativeComponent": 86,
|
||
"./ReactPerf": 88,
|
||
"./ReactRootIndex": 97,
|
||
"./ReactUpdates": 106
|
||
}],
|
||
77: [function(e, t) {
|
||
"use strict";
|
||
|
||
function n(e) {
|
||
return o(document.documentElement, e)
|
||
}
|
||
var r = e("./ReactDOMSelection"),
|
||
o = e("./containsNode"),
|
||
a = e("./focusNode"),
|
||
i = e("./getActiveElement"),
|
||
s = {
|
||
hasSelectionCapabilities: function(e) {
|
||
return e && ("INPUT" === e.nodeName && "text" === e.type || "TEXTAREA" === e.nodeName || "true" === e.contentEditable)
|
||
},
|
||
getSelectionInformation: function() {
|
||
var e = i();
|
||
return {
|
||
focusedElem: e,
|
||
selectionRange: s.hasSelectionCapabilities(e) ? s.getSelection(e) : null
|
||
}
|
||
},
|
||
restoreSelection: function(e) {
|
||
var t = i(),
|
||
r = e.focusedElem,
|
||
o = e.selectionRange;
|
||
t !== r && n(r) && (s.hasSelectionCapabilities(r) && s.setSelection(r, o), a(r))
|
||
},
|
||
getSelection: function(e) {
|
||
var t;
|
||
if ("selectionStart" in e) t = {
|
||
start: e.selectionStart,
|
||
end: e.selectionEnd
|
||
};
|
||
else if (document.selection && "INPUT" === e.nodeName) {
|
||
var n = document.selection.createRange();
|
||
n.parentElement() === e && (t = {
|
||
start: -n.moveStart("character", -e.value.length),
|
||
end: -n.moveEnd("character", -e.value.length)
|
||
})
|
||
} else t = r.getOffsets(e);
|
||
return t || {
|
||
start: 0,
|
||
end: 0
|
||
}
|
||
},
|
||
setSelection: function(e, t) {
|
||
var n = t.start,
|
||
o = t.end;
|
||
if ("undefined" == typeof o && (o = n), "selectionStart" in e) e.selectionStart = n, e.selectionEnd = Math.min(o, e.value.length);
|
||
else if (document.selection && "INPUT" === e.nodeName) {
|
||
var a = e.createTextRange();
|
||
a.collapse(!0), a.moveStart("character", n), a.moveEnd("character", o - n), a.select()
|
||
} else r.setOffsets(e, t)
|
||
}
|
||
};
|
||
t.exports = s
|
||
}, {
|
||
"./ReactDOMSelection": 62,
|
||
"./containsNode": 130,
|
||
"./focusNode": 141,
|
||
"./getActiveElement": 143
|
||
}],
|
||
78: [function(e, t) {
|
||
(function(n) {
|
||
"use strict";
|
||
|
||
function r(e) {
|
||
return f + e.toString(36)
|
||
}
|
||
|
||
function o(e, t) {
|
||
return e.charAt(t) === f || t === e.length
|
||
}
|
||
|
||
function a(e) {
|
||
return "" === e || e.charAt(0) === f && e.charAt(e.length - 1) !== f
|
||
}
|
||
|
||
function i(e, t) {
|
||
return 0 === t.indexOf(e) && o(t, e.length)
|
||
}
|
||
|
||
function s(e) {
|
||
return e ? e.substr(0, e.lastIndexOf(f)) : ""
|
||
}
|
||
|
||
function u(e, t) {
|
||
if ("production" !== n.env.NODE_ENV ? d(a(e) && a(t), "getNextDescendantID(%s, %s): Received an invalid React DOM ID.", e, t) : d(a(e) && a(t)), "production" !== n.env.NODE_ENV ? d(i(e, t), "getNextDescendantID(...): React has made an invalid assumption about the DOM hierarchy. Expected `%s` to be an ancestor of `%s`.", e, t) : d(i(e, t)), e === t) return e;
|
||
var r, s = e.length + h;
|
||
for (r = s; r < t.length && !o(t, r); r++);
|
||
return t.substr(0, r)
|
||
}
|
||
|
||
function c(e, t) {
|
||
var r = Math.min(e.length, t.length);
|
||
if (0 === r) return "";
|
||
for (var i = 0, s = 0; r >= s; s++)
|
||
if (o(e, s) && o(t, s)) i = s;
|
||
else if (e.charAt(s) !== t.charAt(s)) break;
|
||
var u = e.substr(0, i);
|
||
return "production" !== n.env.NODE_ENV ? d(a(u), "getFirstCommonAncestorID(%s, %s): Expected a valid React DOM ID: %s", e, t, u) : d(a(u)), u
|
||
}
|
||
|
||
function l(e, t, r, o, a, c) {
|
||
e = e || "", t = t || "", "production" !== n.env.NODE_ENV ? d(e !== t, "traverseParentPath(...): Cannot traverse from and to the same ID, `%s`.", e) : d(e !== t);
|
||
var l = i(t, e);
|
||
"production" !== n.env.NODE_ENV ? d(l || i(e, t), "traverseParentPath(%s, %s, ...): Cannot traverse from two IDs that do not have a parent path.", e, t) : d(l || i(e, t));
|
||
for (var p = 0, f = l ? s : u, h = e;; h = f(h, t)) {
|
||
var m;
|
||
if (a && h === e || c && h === t || (m = r(h, l, o)), m === !1 || h === t) break;
|
||
"production" !== n.env.NODE_ENV ? d(p++ < v, "traverseParentPath(%s, %s, ...): Detected an infinite loop while traversing the React DOM ID tree. This may be due to malformed IDs: %s", e, t) : d(p++ < v)
|
||
}
|
||
}
|
||
var p = e("./ReactRootIndex"),
|
||
d = e("./invariant"),
|
||
f = ".",
|
||
h = f.length,
|
||
v = 100,
|
||
m = {
|
||
createReactRootID: function() {
|
||
return r(p.createReactRootIndex())
|
||
},
|
||
createReactID: function(e, t) {
|
||
return e + t
|
||
},
|
||
getReactRootIDFromNodeID: function(e) {
|
||
if (e && e.charAt(0) === f && e.length > 1) {
|
||
var t = e.indexOf(f, 1);
|
||
return t > -1 ? e.substr(0, t) : e
|
||
}
|
||
return null
|
||
},
|
||
traverseEnterLeave: function(e, t, n, r, o) {
|
||
var a = c(e, t);
|
||
a !== e && l(e, a, n, r, !1, !0), a !== t && l(a, t, n, o, !0, !1)
|
||
},
|
||
traverseTwoPhase: function(e, t, n) {
|
||
e && (l("", e, t, n, !0, !1), l(e, "", t, n, !1, !0))
|
||
},
|
||
traverseAncestors: function(e, t, n) {
|
||
l("", e, t, n, !0, !1)
|
||
},
|
||
_getFirstCommonAncestorID: c,
|
||
_getNextDescendantID: u,
|
||
isAncestorIDOf: i,
|
||
SEPARATOR: f
|
||
};
|
||
t.exports = m
|
||
}).call(this, e("_process"))
|
||
}, {
|
||
"./ReactRootIndex": 97,
|
||
"./invariant": 157,
|
||
_process: 2
|
||
}],
|
||
79: [function(e, t) {
|
||
"use strict";
|
||
var n = {
|
||
remove: function(e) {
|
||
e._reactInternalInstance = void 0
|
||
},
|
||
get: function(e) {
|
||
return e._reactInternalInstance
|
||
},
|
||
has: function(e) {
|
||
return void 0 !== e._reactInternalInstance
|
||
},
|
||
set: function(e, t) {
|
||
e._reactInternalInstance = t
|
||
}
|
||
};
|
||
t.exports = n
|
||
}, {}],
|
||
80: [function(e, t) {
|
||
"use strict";
|
||
var n = {
|
||
currentlyMountingInstance: null,
|
||
currentlyUnmountingInstance: null
|
||
};
|
||
t.exports = n
|
||
}, {}],
|
||
81: [function(e, t) {
|
||
"use strict";
|
||
|
||
function n(e, t) {
|
||
this.value = e, this.requestChange = t
|
||
}
|
||
|
||
function r(e) {
|
||
var t = {
|
||
value: "undefined" == typeof e ? o.PropTypes.any.isRequired : e.isRequired,
|
||
requestChange: o.PropTypes.func.isRequired
|
||
};
|
||
return o.PropTypes.shape(t)
|
||
}
|
||
var o = e("./React");
|
||
n.PropTypes = {
|
||
link: r
|
||
}, t.exports = n
|
||
}, {
|
||
"./React": 37
|
||
}],
|
||
82: [function(e, t) {
|
||
"use strict";
|
||
var n = e("./adler32"),
|
||
r = {
|
||
CHECKSUM_ATTR_NAME: "data-react-checksum",
|
||
addChecksumToMarkup: function(e) {
|
||
var t = n(e);
|
||
return e.replace(">", " " + r.CHECKSUM_ATTR_NAME + '="' + t + '">')
|
||
},
|
||
canReuseMarkup: function(e, t) {
|
||
var o = t.getAttribute(r.CHECKSUM_ATTR_NAME);
|
||
o = o && parseInt(o, 10);
|
||
var a = n(e);
|
||
return a === o
|
||
}
|
||
};
|
||
t.exports = r
|
||
}, {
|
||
"./adler32": 126
|
||
}],
|
||
83: [function(e, t) {
|
||
(function(n) {
|
||
"use strict";
|
||
|
||
function r(e, t) {
|
||
for (var n = Math.min(e.length, t.length), r = 0; n > r; r++)
|
||
if (e.charAt(r) !== t.charAt(r)) return r;
|
||
return e.length === t.length ? -1 : n
|
||
}
|
||
|
||
function o(e) {
|
||
var t = P(e);
|
||
return t && Y.getID(t)
|
||
}
|
||
|
||
function a(e) {
|
||
var t = i(e);
|
||
if (t)
|
||
if (j.hasOwnProperty(t)) {
|
||
var r = j[t];
|
||
r !== e && ("production" !== n.env.NODE_ENV ? S(!l(r, t), "ReactMount: Two valid but unequal nodes with the same `%s`: %s", L, t) : S(!l(r, t)), j[t] = e)
|
||
} else j[t] = e;
|
||
return t
|
||
}
|
||
|
||
function i(e) {
|
||
return e && e.getAttribute && e.getAttribute(L) || ""
|
||
}
|
||
|
||
function s(e, t) {
|
||
var n = i(e);
|
||
n !== t && delete j[n], e.setAttribute(L, t), j[t] = e
|
||
}
|
||
|
||
function u(e) {
|
||
return j.hasOwnProperty(e) && l(j[e], e) || (j[e] = Y.findReactNodeByID(e)), j[e]
|
||
}
|
||
|
||
function c(e) {
|
||
var t = N.get(e)._rootNodeID;
|
||
return b.isNullComponentID(t) ? null : (j.hasOwnProperty(t) && l(j[t], t) || (j[t] = Y.findReactNodeByID(t)), j[t])
|
||
}
|
||
|
||
function l(e, t) {
|
||
if (e) {
|
||
"production" !== n.env.NODE_ENV ? S(i(e) === t, "ReactMount: Unexpected modification of `%s`", L) : S(i(e) === t);
|
||
var r = Y.findReactContainerForID(t);
|
||
if (r && T(r, e)) return !0
|
||
}
|
||
return !1
|
||
}
|
||
|
||
function p(e) {
|
||
delete j[e]
|
||
}
|
||
|
||
function d(e) {
|
||
var t = j[e];
|
||
return t && l(t, e) ? void(z = t) : !1
|
||
}
|
||
|
||
function f(e) {
|
||
z = null, _.traverseAncestors(e, d);
|
||
var t = z;
|
||
return z = null, t
|
||
}
|
||
|
||
function h(e, t, n, r, o) {
|
||
var a = D.mountComponent(e, t, r, x);
|
||
e._isTopLevel = !0, Y._mountImageIntoNode(a, n, o)
|
||
}
|
||
|
||
function v(e, t, n, r) {
|
||
var o = M.ReactReconcileTransaction.getPooled();
|
||
o.perform(h, null, e, t, n, o, r), M.ReactReconcileTransaction.release(o)
|
||
}
|
||
var m = e("./DOMProperty"),
|
||
y = e("./ReactBrowserEventEmitter"),
|
||
g = e("./ReactCurrentOwner"),
|
||
E = e("./ReactElement"),
|
||
C = e("./ReactElementValidator"),
|
||
b = e("./ReactEmptyComponent"),
|
||
_ = e("./ReactInstanceHandles"),
|
||
N = e("./ReactInstanceMap"),
|
||
O = e("./ReactMarkupChecksum"),
|
||
R = e("./ReactPerf"),
|
||
D = e("./ReactReconciler"),
|
||
w = e("./ReactUpdateQueue"),
|
||
M = e("./ReactUpdates"),
|
||
x = e("./emptyObject"),
|
||
T = e("./containsNode"),
|
||
P = e("./getReactRootElementInContainer"),
|
||
I = e("./instantiateReactComponent"),
|
||
S = e("./invariant"),
|
||
k = e("./setInnerHTML"),
|
||
A = e("./shouldUpdateReactComponent"),
|
||
V = e("./warning"),
|
||
U = _.SEPARATOR,
|
||
L = m.ID_ATTRIBUTE_NAME,
|
||
j = {},
|
||
F = 1,
|
||
B = 9,
|
||
W = {},
|
||
H = {};
|
||
if ("production" !== n.env.NODE_ENV) var q = {};
|
||
var K = [],
|
||
z = null,
|
||
Y = {
|
||
_instancesByReactRootID: W,
|
||
scrollMonitor: function(e, t) {
|
||
t()
|
||
},
|
||
_updateRootComponent: function(e, t, r, a) {
|
||
return "production" !== n.env.NODE_ENV && C.checkAndWarnForMutatedProps(t), Y.scrollMonitor(r, function() {
|
||
w.enqueueElementInternal(e, t), a && w.enqueueCallbackInternal(e, a)
|
||
}), "production" !== n.env.NODE_ENV && (q[o(r)] = P(r)), e
|
||
},
|
||
_registerComponent: function(e, t) {
|
||
"production" !== n.env.NODE_ENV ? S(t && (t.nodeType === F || t.nodeType === B), "_registerComponent(...): Target container is not a DOM element.") : S(t && (t.nodeType === F || t.nodeType === B)), y.ensureScrollValueMonitoring();
|
||
var r = Y.registerContainer(t);
|
||
return W[r] = e, r
|
||
},
|
||
_renderNewRootComponent: function(e, t, r) {
|
||
"production" !== n.env.NODE_ENV ? V(null == g.current, "_renderNewRootComponent(): Render methods should be a pure function of props and state; triggering nested component updates from render is not allowed. If necessary, trigger nested updates in componentDidUpdate.") : null;
|
||
var o = I(e, null),
|
||
a = Y._registerComponent(o, t);
|
||
return M.batchedUpdates(v, o, a, t, r), "production" !== n.env.NODE_ENV && (q[a] = P(t)), o
|
||
},
|
||
render: function(e, t, r) {
|
||
"production" !== n.env.NODE_ENV ? S(E.isValidElement(e), "React.render(): Invalid component element.%s", "string" == typeof e ? " Instead of passing an element string, make sure to instantiate it by passing it to React.createElement." : "function" == typeof e ? " Instead of passing a component class, make sure to instantiate it by passing it to React.createElement." : null != e && void 0 !== e.props ? " This may be caused by unintentionally loading two independent copies of React." : "") : S(E.isValidElement(e));
|
||
var a = W[o(t)];
|
||
if (a) {
|
||
var i = a._currentElement;
|
||
if (A(i, e)) return Y._updateRootComponent(a, e, t, r).getPublicInstance();
|
||
Y.unmountComponentAtNode(t)
|
||
}
|
||
var s = P(t),
|
||
u = s && Y.isRenderedByReact(s);
|
||
if ("production" !== n.env.NODE_ENV && (!u || s.nextSibling))
|
||
for (var c = s; c;) {
|
||
if (Y.isRenderedByReact(c)) {
|
||
"production" !== n.env.NODE_ENV ? V(!1, "render(): Target node has markup rendered by React, but there are unrelated nodes as well. This is most commonly caused by white-space inserted around server-rendered markup.") : null;
|
||
break
|
||
}
|
||
c = c.nextSibling
|
||
}
|
||
var l = u && !a,
|
||
p = Y._renderNewRootComponent(e, t, l).getPublicInstance();
|
||
return r && r.call(p), p
|
||
},
|
||
constructAndRenderComponent: function(e, t, n) {
|
||
var r = E.createElement(e, t);
|
||
return Y.render(r, n)
|
||
},
|
||
constructAndRenderComponentByID: function(e, t, r) {
|
||
var o = document.getElementById(r);
|
||
return "production" !== n.env.NODE_ENV ? S(o, 'Tried to get element with id of "%s" but it is not present on the page.', r) : S(o), Y.constructAndRenderComponent(e, t, o)
|
||
},
|
||
registerContainer: function(e) {
|
||
var t = o(e);
|
||
return t && (t = _.getReactRootIDFromNodeID(t)), t || (t = _.createReactRootID()), H[t] = e, t
|
||
},
|
||
unmountComponentAtNode: function(e) {
|
||
"production" !== n.env.NODE_ENV ? V(null == g.current, "unmountComponentAtNode(): Render methods should be a pure function of props and state; triggering nested component updates from render is not allowed. If necessary, trigger nested updates in componentDidUpdate.") : null, "production" !== n.env.NODE_ENV ? S(e && (e.nodeType === F || e.nodeType === B), "unmountComponentAtNode(...): Target container is not a DOM element.") : S(e && (e.nodeType === F || e.nodeType === B));
|
||
var t = o(e),
|
||
r = W[t];
|
||
return r ? (Y.unmountComponentFromNode(r, e), delete W[t], delete H[t], "production" !== n.env.NODE_ENV && delete q[t], !0) : !1
|
||
},
|
||
unmountComponentFromNode: function(e, t) {
|
||
for (D.unmountComponent(e), t.nodeType === B && (t = t.documentElement); t.lastChild;) t.removeChild(t.lastChild)
|
||
},
|
||
findReactContainerForID: function(e) {
|
||
var t = _.getReactRootIDFromNodeID(e),
|
||
r = H[t];
|
||
if ("production" !== n.env.NODE_ENV) {
|
||
var o = q[t];
|
||
if (o && o.parentNode !== r) {
|
||
"production" !== n.env.NODE_ENV ? S(i(o) === t, "ReactMount: Root element ID differed from reactRootID.") : S(i(o) === t);
|
||
var a = r.firstChild;
|
||
a && t === i(a) ? q[t] = a : "production" !== n.env.NODE_ENV ? V(!1, "ReactMount: Root element has been removed from its original container. New container:", o.parentNode) : null
|
||
}
|
||
}
|
||
return r
|
||
},
|
||
findReactNodeByID: function(e) {
|
||
var t = Y.findReactContainerForID(e);
|
||
return Y.findComponentRoot(t, e)
|
||
},
|
||
isRenderedByReact: function(e) {
|
||
if (1 !== e.nodeType) return !1;
|
||
var t = Y.getID(e);
|
||
return t ? t.charAt(0) === U : !1
|
||
},
|
||
getFirstReactDOM: function(e) {
|
||
for (var t = e; t && t.parentNode !== t;) {
|
||
if (Y.isRenderedByReact(t)) return t;
|
||
t = t.parentNode
|
||
}
|
||
return null
|
||
},
|
||
findComponentRoot: function(e, t) {
|
||
var r = K,
|
||
o = 0,
|
||
a = f(t) || e;
|
||
for (r[0] = a.firstChild, r.length = 1; o < r.length;) {
|
||
for (var i, s = r[o++]; s;) {
|
||
var u = Y.getID(s);
|
||
u ? t === u ? i = s : _.isAncestorIDOf(u, t) && (r.length = o = 0, r.push(s.firstChild)) : r.push(s.firstChild), s = s.nextSibling
|
||
}
|
||
if (i) return r.length = 0, i
|
||
}
|
||
r.length = 0, "production" !== n.env.NODE_ENV ? S(!1, "findComponentRoot(..., %s): Unable to find element. This probably means the DOM was unexpectedly mutated (e.g., by the browser), usually due to forgetting a <tbody> when using tables, nesting tags like <form>, <p>, or <a>, or using non-SVG elements in an <svg> parent. Try inspecting the child nodes of the element with React ID `%s`.", t, Y.getID(e)) : S(!1)
|
||
},
|
||
_mountImageIntoNode: function(e, t, o) {
|
||
if ("production" !== n.env.NODE_ENV ? S(t && (t.nodeType === F || t.nodeType === B), "mountComponentIntoNode(...): Target container is not valid.") : S(t && (t.nodeType === F || t.nodeType === B)), o) {
|
||
var a = P(t);
|
||
if (O.canReuseMarkup(e, a)) return;
|
||
var i = a.getAttribute(O.CHECKSUM_ATTR_NAME);
|
||
a.removeAttribute(O.CHECKSUM_ATTR_NAME);
|
||
var s = a.outerHTML;
|
||
a.setAttribute(O.CHECKSUM_ATTR_NAME, i);
|
||
var u = r(e, s),
|
||
c = " (client) " + e.substring(u - 20, u + 20) + "\n (server) " + s.substring(u - 20, u + 20);
|
||
"production" !== n.env.NODE_ENV ? S(t.nodeType !== B, "You're trying to render a component to the document using server rendering but the checksum was invalid. This usually means you rendered a different component type or props on the client from the one on the server, or your render() methods are impure. React cannot handle this case due to cross-browser quirks by rendering at the document root. You should look for environment dependent code in your components and ensure the props are the same client and server side:\n%s", c) : S(t.nodeType !== B), "production" !== n.env.NODE_ENV && ("production" !== n.env.NODE_ENV ? V(!1, "React attempted to reuse markup in a container but the checksum was invalid. This generally means that you are using server rendering and the markup generated on the server was not what the client was expecting. React injected new markup to compensate which works but you have lost many of the benefits of server rendering. Instead, figure out why the markup being generated is different on the client or server:\n%s", c) : null)
|
||
}
|
||
"production" !== n.env.NODE_ENV ? S(t.nodeType !== B, "You're trying to render a component to the document but you didn't use server rendering. We can't do this without using server rendering due to cross-browser quirks. See React.renderToString() for server rendering.") : S(t.nodeType !== B), k(t, e)
|
||
},
|
||
getReactRootID: o,
|
||
getID: a,
|
||
setID: s,
|
||
getNode: u,
|
||
getNodeFromInstance: c,
|
||
purgeID: p
|
||
};
|
||
R.measureMethods(Y, "ReactMount", {
|
||
_renderNewRootComponent: "_renderNewRootComponent",
|
||
_mountImageIntoNode: "_mountImageIntoNode"
|
||
}), t.exports = Y
|
||
}).call(this, e("_process"))
|
||
}, {
|
||
"./DOMProperty": 17,
|
||
"./ReactBrowserEventEmitter": 39,
|
||
"./ReactCurrentOwner": 51,
|
||
"./ReactElement": 69,
|
||
"./ReactElementValidator": 70,
|
||
"./ReactEmptyComponent": 71,
|
||
"./ReactInstanceHandles": 78,
|
||
"./ReactInstanceMap": 79,
|
||
"./ReactMarkupChecksum": 82,
|
||
"./ReactPerf": 88,
|
||
"./ReactReconciler": 95,
|
||
"./ReactUpdateQueue": 105,
|
||
"./ReactUpdates": 106,
|
||
"./containsNode": 130,
|
||
"./emptyObject": 137,
|
||
"./getReactRootElementInContainer": 151,
|
||
"./instantiateReactComponent": 156,
|
||
"./invariant": 157,
|
||
"./setInnerHTML": 171,
|
||
"./shouldUpdateReactComponent": 174,
|
||
"./warning": 178,
|
||
_process: 2
|
||
}],
|
||
84: [function(e, t) {
|
||
"use strict";
|
||
|
||
function n(e, t, n) {
|
||
f.push({
|
||
parentID: e,
|
||
parentNode: null,
|
||
type: c.INSERT_MARKUP,
|
||
markupIndex: h.push(t) - 1,
|
||
textContent: null,
|
||
fromIndex: null,
|
||
toIndex: n
|
||
})
|
||
}
|
||
|
||
function r(e, t, n) {
|
||
f.push({
|
||
parentID: e,
|
||
parentNode: null,
|
||
type: c.MOVE_EXISTING,
|
||
markupIndex: null,
|
||
textContent: null,
|
||
fromIndex: t,
|
||
toIndex: n
|
||
})
|
||
}
|
||
|
||
function o(e, t) {
|
||
f.push({
|
||
parentID: e,
|
||
parentNode: null,
|
||
type: c.REMOVE_NODE,
|
||
markupIndex: null,
|
||
textContent: null,
|
||
fromIndex: t,
|
||
toIndex: null
|
||
})
|
||
}
|
||
|
||
function a(e, t) {
|
||
f.push({
|
||
parentID: e,
|
||
parentNode: null,
|
||
type: c.TEXT_CONTENT,
|
||
markupIndex: null,
|
||
textContent: t,
|
||
fromIndex: null,
|
||
toIndex: null
|
||
})
|
||
}
|
||
|
||
function i() {
|
||
f.length && (u.processChildrenUpdates(f, h), s())
|
||
}
|
||
|
||
function s() {
|
||
f.length = 0, h.length = 0
|
||
}
|
||
var u = e("./ReactComponentEnvironment"),
|
||
c = e("./ReactMultiChildUpdateTypes"),
|
||
l = e("./ReactReconciler"),
|
||
p = e("./ReactChildReconciler"),
|
||
d = 0,
|
||
f = [],
|
||
h = [],
|
||
v = {
|
||
Mixin: {
|
||
mountChildren: function(e, t, n) {
|
||
var r = p.instantiateChildren(e, t, n);
|
||
this._renderedChildren = r;
|
||
var o = [],
|
||
a = 0;
|
||
for (var i in r)
|
||
if (r.hasOwnProperty(i)) {
|
||
var s = r[i],
|
||
u = this._rootNodeID + i,
|
||
c = l.mountComponent(s, u, t, n);
|
||
s._mountIndex = a, o.push(c), a++
|
||
} return o
|
||
},
|
||
updateTextContent: function(e) {
|
||
d++;
|
||
var t = !0;
|
||
try {
|
||
var n = this._renderedChildren;
|
||
p.unmountChildren(n);
|
||
for (var r in n) n.hasOwnProperty(r) && this._unmountChildByName(n[r], r);
|
||
this.setTextContent(e), t = !1
|
||
} finally {
|
||
d--, d || (t ? s() : i())
|
||
}
|
||
},
|
||
updateChildren: function(e, t, n) {
|
||
d++;
|
||
var r = !0;
|
||
try {
|
||
this._updateChildren(e, t, n), r = !1
|
||
} finally {
|
||
d--, d || (r ? s() : i())
|
||
}
|
||
},
|
||
_updateChildren: function(e, t, n) {
|
||
var r = this._renderedChildren,
|
||
o = p.updateChildren(r, e, t, n);
|
||
if (this._renderedChildren = o, o || r) {
|
||
var a, i = 0,
|
||
s = 0;
|
||
for (a in o)
|
||
if (o.hasOwnProperty(a)) {
|
||
var u = r && r[a],
|
||
c = o[a];
|
||
u === c ? (this.moveChild(u, s, i), i = Math.max(u._mountIndex, i), u._mountIndex = s) : (u && (i = Math.max(u._mountIndex, i), this._unmountChildByName(u, a)), this._mountChildByNameAtIndex(c, a, s, t, n)), s++
|
||
} for (a in r) !r.hasOwnProperty(a) || o && o.hasOwnProperty(a) || this._unmountChildByName(r[a], a)
|
||
}
|
||
},
|
||
unmountChildren: function() {
|
||
var e = this._renderedChildren;
|
||
p.unmountChildren(e), this._renderedChildren = null
|
||
},
|
||
moveChild: function(e, t, n) {
|
||
e._mountIndex < n && r(this._rootNodeID, e._mountIndex, t)
|
||
},
|
||
createChild: function(e, t) {
|
||
n(this._rootNodeID, t, e._mountIndex)
|
||
},
|
||
removeChild: function(e) {
|
||
o(this._rootNodeID, e._mountIndex)
|
||
},
|
||
setTextContent: function(e) {
|
||
a(this._rootNodeID, e)
|
||
},
|
||
_mountChildByNameAtIndex: function(e, t, n, r, o) {
|
||
var a = this._rootNodeID + t,
|
||
i = l.mountComponent(e, a, r, o);
|
||
e._mountIndex = n, this.createChild(e, i)
|
||
},
|
||
_unmountChildByName: function(e) {
|
||
this.removeChild(e), e._mountIndex = null
|
||
}
|
||
}
|
||
};
|
||
t.exports = v
|
||
}, {
|
||
"./ReactChildReconciler": 42,
|
||
"./ReactComponentEnvironment": 47,
|
||
"./ReactMultiChildUpdateTypes": 85,
|
||
"./ReactReconciler": 95
|
||
}],
|
||
85: [function(e, t) {
|
||
"use strict";
|
||
var n = e("./keyMirror"),
|
||
r = n({
|
||
INSERT_MARKUP: null,
|
||
MOVE_EXISTING: null,
|
||
REMOVE_NODE: null,
|
||
TEXT_CONTENT: null
|
||
});
|
||
t.exports = r
|
||
}, {
|
||
"./keyMirror": 163
|
||
}],
|
||
86: [function(e, t) {
|
||
(function(n) {
|
||
"use strict";
|
||
|
||
function r(e) {
|
||
if ("function" == typeof e.type) return e.type;
|
||
var t = e.type,
|
||
n = p[t];
|
||
return null == n && (p[t] = n = c(t)), n
|
||
}
|
||
|
||
function o(e) {
|
||
return "production" !== n.env.NODE_ENV ? u(l, "There is no registered component for the tag %s", e.type) : u(l), new l(e.type, e.props)
|
||
}
|
||
|
||
function a(e) {
|
||
return new d(e)
|
||
}
|
||
|
||
function i(e) {
|
||
return e instanceof d
|
||
}
|
||
var s = e("./Object.assign"),
|
||
u = e("./invariant"),
|
||
c = null,
|
||
l = null,
|
||
p = {},
|
||
d = null,
|
||
f = {
|
||
injectGenericComponentClass: function(e) {
|
||
l = e
|
||
},
|
||
injectTextComponentClass: function(e) {
|
||
d = e
|
||
},
|
||
injectComponentClasses: function(e) {
|
||
s(p, e)
|
||
},
|
||
injectAutoWrapper: function(e) {
|
||
c = e
|
||
}
|
||
},
|
||
h = {
|
||
getComponentClassForElement: r,
|
||
createInternalComponent: o,
|
||
createInstanceForText: a,
|
||
isTextComponent: i,
|
||
injection: f
|
||
};
|
||
t.exports = h
|
||
}).call(this, e("_process"))
|
||
}, {
|
||
"./Object.assign": 35,
|
||
"./invariant": 157,
|
||
_process: 2
|
||
}],
|
||
87: [function(e, t) {
|
||
(function(n) {
|
||
"use strict";
|
||
var r = e("./invariant"),
|
||
o = {
|
||
isValidOwner: function(e) {
|
||
return !(!e || "function" != typeof e.attachRef || "function" != typeof e.detachRef)
|
||
},
|
||
addComponentAsRefTo: function(e, t, a) {
|
||
"production" !== n.env.NODE_ENV ? r(o.isValidOwner(a), "addComponentAsRefTo(...): Only a ReactOwner can have refs. This usually means that you're trying to add a ref to a component that doesn't have an owner (that is, was not created inside of another component's `render` method). Try rendering this component inside of a new top-level component which will hold the ref.") : r(o.isValidOwner(a)), a.attachRef(t, e)
|
||
},
|
||
removeComponentAsRefFrom: function(e, t, a) {
|
||
"production" !== n.env.NODE_ENV ? r(o.isValidOwner(a), "removeComponentAsRefFrom(...): Only a ReactOwner can have refs. This usually means that you're trying to remove a ref to a component that doesn't have an owner (that is, was not created inside of another component's `render` method). Try rendering this component inside of a new top-level component which will hold the ref.") : r(o.isValidOwner(a)), a.getPublicInstance().refs[t] === e.getPublicInstance() && a.detachRef(t)
|
||
}
|
||
};
|
||
t.exports = o
|
||
}).call(this, e("_process"))
|
||
}, {
|
||
"./invariant": 157,
|
||
_process: 2
|
||
}],
|
||
88: [function(e, t) {
|
||
(function(e) {
|
||
"use strict";
|
||
|
||
function n(e, t, n) {
|
||
return n
|
||
}
|
||
var r = {
|
||
enableMeasure: !1,
|
||
storedMeasure: n,
|
||
measureMethods: function(t, n, o) {
|
||
if ("production" !== e.env.NODE_ENV)
|
||
for (var a in o) o.hasOwnProperty(a) && (t[a] = r.measure(n, o[a], t[a]))
|
||
},
|
||
measure: function(t, n, o) {
|
||
if ("production" !== e.env.NODE_ENV) {
|
||
var a = null,
|
||
i = function() {
|
||
return r.enableMeasure ? (a || (a = r.storedMeasure(t, n, o)), a.apply(this, arguments)) : o.apply(this, arguments)
|
||
};
|
||
return i.displayName = t + "_" + n, i
|
||
}
|
||
return o
|
||
},
|
||
injection: {
|
||
injectMeasure: function(e) {
|
||
r.storedMeasure = e
|
||
}
|
||
}
|
||
};
|
||
t.exports = r
|
||
}).call(this, e("_process"))
|
||
}, {
|
||
_process: 2
|
||
}],
|
||
89: [function(e, t) {
|
||
"use strict";
|
||
|
||
function n(e) {
|
||
return function(t, n, r) {
|
||
t[n] = t.hasOwnProperty(n) ? e(t[n], r) : r
|
||
}
|
||
}
|
||
|
||
function r(e, t) {
|
||
for (var n in t)
|
||
if (t.hasOwnProperty(n)) {
|
||
var r = u[n];
|
||
r && u.hasOwnProperty(n) ? r(e, n, t[n]) : e.hasOwnProperty(n) || (e[n] = t[n])
|
||
} return e
|
||
}
|
||
var o = e("./Object.assign"),
|
||
a = e("./emptyFunction"),
|
||
i = e("./joinClasses"),
|
||
s = n(function(e, t) {
|
||
return o({}, t, e)
|
||
}),
|
||
u = {
|
||
children: a,
|
||
className: n(i),
|
||
style: s
|
||
},
|
||
c = {
|
||
mergeProps: function(e, t) {
|
||
return r(o({}, e), t)
|
||
}
|
||
};
|
||
t.exports = c
|
||
}, {
|
||
"./Object.assign": 35,
|
||
"./emptyFunction": 136,
|
||
"./joinClasses": 162
|
||
}],
|
||
90: [function(e, t) {
|
||
(function(e) {
|
||
"use strict";
|
||
var n = {};
|
||
"production" !== e.env.NODE_ENV && (n = {
|
||
prop: "prop",
|
||
context: "context",
|
||
childContext: "child context"
|
||
}), t.exports = n
|
||
}).call(this, e("_process"))
|
||
}, {
|
||
_process: 2
|
||
}],
|
||
91: [function(e, t) {
|
||
"use strict";
|
||
var n = e("./keyMirror"),
|
||
r = n({
|
||
prop: null,
|
||
context: null,
|
||
childContext: null
|
||
});
|
||
t.exports = r
|
||
}, {
|
||
"./keyMirror": 163
|
||
}],
|
||
92: [function(e, t) {
|
||
"use strict";
|
||
|
||
function n(e) {
|
||
function t(t, n, r, o, a) {
|
||
if (o = o || C, null == n[r]) {
|
||
var i = g[a];
|
||
return t ? new Error("Required " + i + " `" + r + "` was not specified in " + ("`" + o + "`.")) : null
|
||
}
|
||
return e(n, r, o, a)
|
||
}
|
||
var n = t.bind(null, !1);
|
||
return n.isRequired = t.bind(null, !0), n
|
||
}
|
||
|
||
function r(e) {
|
||
function t(t, n, r, o) {
|
||
var a = t[n],
|
||
i = h(a);
|
||
if (i !== e) {
|
||
var s = g[o],
|
||
u = v(a);
|
||
return new Error("Invalid " + s + " `" + n + "` of type `" + u + "` " + ("supplied to `" + r + "`, expected `" + e + "`."))
|
||
}
|
||
return null
|
||
}
|
||
return n(t)
|
||
}
|
||
|
||
function o() {
|
||
return n(E.thatReturns(null))
|
||
}
|
||
|
||
function a(e) {
|
||
function t(t, n, r, o) {
|
||
var a = t[n];
|
||
if (!Array.isArray(a)) {
|
||
var i = g[o],
|
||
s = h(a);
|
||
return new Error("Invalid " + i + " `" + n + "` of type " + ("`" + s + "` supplied to `" + r + "`, expected an array."))
|
||
}
|
||
for (var u = 0; u < a.length; u++) {
|
||
var c = e(a, u, r, o);
|
||
if (c instanceof Error) return c
|
||
}
|
||
return null
|
||
}
|
||
return n(t)
|
||
}
|
||
|
||
function i() {
|
||
function e(e, t, n, r) {
|
||
if (!m.isValidElement(e[t])) {
|
||
var o = g[r];
|
||
return new Error("Invalid " + o + " `" + t + "` supplied to " + ("`" + n + "`, expected a ReactElement."))
|
||
}
|
||
return null
|
||
}
|
||
return n(e)
|
||
}
|
||
|
||
function s(e) {
|
||
function t(t, n, r, o) {
|
||
if (!(t[n] instanceof e)) {
|
||
var a = g[o],
|
||
i = e.name || C;
|
||
return new Error("Invalid " + a + " `" + n + "` supplied to " + ("`" + r + "`, expected instance of `" + i + "`."))
|
||
}
|
||
return null
|
||
}
|
||
return n(t)
|
||
}
|
||
|
||
function u(e) {
|
||
function t(t, n, r, o) {
|
||
for (var a = t[n], i = 0; i < e.length; i++)
|
||
if (a === e[i]) return null;
|
||
var s = g[o],
|
||
u = JSON.stringify(e);
|
||
return new Error("Invalid " + s + " `" + n + "` of value `" + a + "` " + ("supplied to `" + r + "`, expected one of " + u + "."))
|
||
}
|
||
return n(t)
|
||
}
|
||
|
||
function c(e) {
|
||
function t(t, n, r, o) {
|
||
var a = t[n],
|
||
i = h(a);
|
||
if ("object" !== i) {
|
||
var s = g[o];
|
||
return new Error("Invalid " + s + " `" + n + "` of type " + ("`" + i + "` supplied to `" + r + "`, expected an object."))
|
||
}
|
||
for (var u in a)
|
||
if (a.hasOwnProperty(u)) {
|
||
var c = e(a, u, r, o);
|
||
if (c instanceof Error) return c
|
||
} return null
|
||
}
|
||
return n(t)
|
||
}
|
||
|
||
function l(e) {
|
||
function t(t, n, r, o) {
|
||
for (var a = 0; a < e.length; a++) {
|
||
var i = e[a];
|
||
if (null == i(t, n, r, o)) return null
|
||
}
|
||
var s = g[o];
|
||
return new Error("Invalid " + s + " `" + n + "` supplied to " + ("`" + r + "`."))
|
||
}
|
||
return n(t)
|
||
}
|
||
|
||
function p() {
|
||
function e(e, t, n, r) {
|
||
if (!f(e[t])) {
|
||
var o = g[r];
|
||
return new Error("Invalid " + o + " `" + t + "` supplied to " + ("`" + n + "`, expected a ReactNode."))
|
||
}
|
||
return null
|
||
}
|
||
return n(e)
|
||
}
|
||
|
||
function d(e) {
|
||
function t(t, n, r, o) {
|
||
var a = t[n],
|
||
i = h(a);
|
||
if ("object" !== i) {
|
||
var s = g[o];
|
||
return new Error("Invalid " + s + " `" + n + "` of type `" + i + "` " + ("supplied to `" + r + "`, expected `object`."))
|
||
}
|
||
for (var u in e) {
|
||
var c = e[u];
|
||
if (c) {
|
||
var l = c(a, u, r, o);
|
||
if (l) return l
|
||
}
|
||
}
|
||
return null
|
||
}
|
||
return n(t)
|
||
}
|
||
|
||
function f(e) {
|
||
switch (typeof e) {
|
||
case "number":
|
||
case "string":
|
||
case "undefined":
|
||
return !0;
|
||
case "boolean":
|
||
return !e;
|
||
case "object":
|
||
if (Array.isArray(e)) return e.every(f);
|
||
if (null === e || m.isValidElement(e)) return !0;
|
||
e = y.extractIfFragment(e);
|
||
for (var t in e)
|
||
if (!f(e[t])) return !1;
|
||
return !0;
|
||
default:
|
||
return !1
|
||
}
|
||
}
|
||
|
||
function h(e) {
|
||
var t = typeof e;
|
||
return Array.isArray(e) ? "array" : e instanceof RegExp ? "object" : t
|
||
}
|
||
|
||
function v(e) {
|
||
var t = h(e);
|
||
if ("object" === t) {
|
||
if (e instanceof Date) return "date";
|
||
if (e instanceof RegExp) return "regexp"
|
||
}
|
||
return t
|
||
}
|
||
var m = e("./ReactElement"),
|
||
y = e("./ReactFragment"),
|
||
g = e("./ReactPropTypeLocationNames"),
|
||
E = e("./emptyFunction"),
|
||
C = "<<anonymous>>",
|
||
b = i(),
|
||
_ = p(),
|
||
N = {
|
||
array: r("array"),
|
||
bool: r("boolean"),
|
||
func: r("function"),
|
||
number: r("number"),
|
||
object: r("object"),
|
||
string: r("string"),
|
||
any: o(),
|
||
arrayOf: a,
|
||
element: b,
|
||
instanceOf: s,
|
||
node: _,
|
||
objectOf: c,
|
||
oneOf: u,
|
||
oneOfType: l,
|
||
shape: d
|
||
};
|
||
t.exports = N
|
||
}, {
|
||
"./ReactElement": 69,
|
||
"./ReactFragment": 75,
|
||
"./ReactPropTypeLocationNames": 90,
|
||
"./emptyFunction": 136
|
||
}],
|
||
93: [function(e, t) {
|
||
"use strict";
|
||
|
||
function n() {
|
||
this.listenersToPut = []
|
||
}
|
||
var r = e("./PooledClass"),
|
||
o = e("./ReactBrowserEventEmitter"),
|
||
a = e("./Object.assign");
|
||
a(n.prototype, {
|
||
enqueuePutListener: function(e, t, n) {
|
||
this.listenersToPut.push({
|
||
rootNodeID: e,
|
||
propKey: t,
|
||
propValue: n
|
||
})
|
||
},
|
||
putListeners: function() {
|
||
for (var e = 0; e < this.listenersToPut.length; e++) {
|
||
var t = this.listenersToPut[e];
|
||
o.putListener(t.rootNodeID, t.propKey, t.propValue)
|
||
}
|
||
},
|
||
reset: function() {
|
||
this.listenersToPut.length = 0
|
||
},
|
||
destructor: function() {
|
||
this.reset()
|
||
}
|
||
}), r.addPoolingTo(n), t.exports = n
|
||
}, {
|
||
"./Object.assign": 35,
|
||
"./PooledClass": 36,
|
||
"./ReactBrowserEventEmitter": 39
|
||
}],
|
||
94: [function(e, t) {
|
||
"use strict";
|
||
|
||
function n() {
|
||
this.reinitializeTransaction(), this.renderToStaticMarkup = !1, this.reactMountReady = r.getPooled(null), this.putListenerQueue = s.getPooled()
|
||
}
|
||
var r = e("./CallbackQueue"),
|
||
o = e("./PooledClass"),
|
||
a = e("./ReactBrowserEventEmitter"),
|
||
i = e("./ReactInputSelection"),
|
||
s = e("./ReactPutListenerQueue"),
|
||
u = e("./Transaction"),
|
||
c = e("./Object.assign"),
|
||
l = {
|
||
initialize: i.getSelectionInformation,
|
||
close: i.restoreSelection
|
||
},
|
||
p = {
|
||
initialize: function() {
|
||
var e = a.isEnabled();
|
||
return a.setEnabled(!1), e
|
||
},
|
||
close: function(e) {
|
||
a.setEnabled(e)
|
||
}
|
||
},
|
||
d = {
|
||
initialize: function() {
|
||
this.reactMountReady.reset()
|
||
},
|
||
close: function() {
|
||
this.reactMountReady.notifyAll()
|
||
}
|
||
},
|
||
f = {
|
||
initialize: function() {
|
||
this.putListenerQueue.reset()
|
||
},
|
||
close: function() {
|
||
this.putListenerQueue.putListeners()
|
||
}
|
||
},
|
||
h = [f, l, p, d],
|
||
v = {
|
||
getTransactionWrappers: function() {
|
||
return h
|
||
},
|
||
getReactMountReady: function() {
|
||
return this.reactMountReady
|
||
},
|
||
getPutListenerQueue: function() {
|
||
return this.putListenerQueue
|
||
},
|
||
destructor: function() {
|
||
r.release(this.reactMountReady), this.reactMountReady = null, s.release(this.putListenerQueue), this.putListenerQueue = null
|
||
}
|
||
};
|
||
c(n.prototype, u.Mixin, v), o.addPoolingTo(n), t.exports = n
|
||
}, {
|
||
"./CallbackQueue": 13,
|
||
"./Object.assign": 35,
|
||
"./PooledClass": 36,
|
||
"./ReactBrowserEventEmitter": 39,
|
||
"./ReactInputSelection": 77,
|
||
"./ReactPutListenerQueue": 93,
|
||
"./Transaction": 123
|
||
}],
|
||
95: [function(e, t) {
|
||
(function(n) {
|
||
"use strict";
|
||
|
||
function r() {
|
||
o.attachRefs(this, this._currentElement)
|
||
}
|
||
var o = e("./ReactRef"),
|
||
a = e("./ReactElementValidator"),
|
||
i = {
|
||
mountComponent: function(e, t, o, i) {
|
||
var s = e.mountComponent(t, o, i);
|
||
return "production" !== n.env.NODE_ENV && a.checkAndWarnForMutatedProps(e._currentElement), o.getReactMountReady().enqueue(r, e), s
|
||
},
|
||
unmountComponent: function(e) {
|
||
o.detachRefs(e, e._currentElement), e.unmountComponent()
|
||
},
|
||
receiveComponent: function(e, t, i, s) {
|
||
var u = e._currentElement;
|
||
if (t !== u || null == t._owner) {
|
||
"production" !== n.env.NODE_ENV && a.checkAndWarnForMutatedProps(t);
|
||
var c = o.shouldUpdateRefs(u, t);
|
||
c && o.detachRefs(e, u), e.receiveComponent(t, i, s), c && i.getReactMountReady().enqueue(r, e)
|
||
}
|
||
},
|
||
performUpdateIfNecessary: function(e, t) {
|
||
e.performUpdateIfNecessary(t)
|
||
}
|
||
};
|
||
t.exports = i
|
||
}).call(this, e("_process"))
|
||
}, {
|
||
"./ReactElementValidator": 70,
|
||
"./ReactRef": 96,
|
||
_process: 2
|
||
}],
|
||
96: [function(e, t) {
|
||
"use strict";
|
||
|
||
function n(e, t, n) {
|
||
"function" == typeof e ? e(t.getPublicInstance()) : o.addComponentAsRefTo(t, e, n)
|
||
}
|
||
|
||
function r(e, t, n) {
|
||
"function" == typeof e ? e(null) : o.removeComponentAsRefFrom(t, e, n)
|
||
}
|
||
var o = e("./ReactOwner"),
|
||
a = {};
|
||
a.attachRefs = function(e, t) {
|
||
var r = t.ref;
|
||
null != r && n(r, e, t._owner)
|
||
}, a.shouldUpdateRefs = function(e, t) {
|
||
return t._owner !== e._owner || t.ref !== e.ref
|
||
}, a.detachRefs = function(e, t) {
|
||
var n = t.ref;
|
||
null != n && r(n, e, t._owner)
|
||
}, t.exports = a
|
||
}, {
|
||
"./ReactOwner": 87
|
||
}],
|
||
97: [function(e, t) {
|
||
"use strict";
|
||
var n = {
|
||
injectCreateReactRootIndex: function(e) {
|
||
r.createReactRootIndex = e
|
||
}
|
||
},
|
||
r = {
|
||
createReactRootIndex: null,
|
||
injection: n
|
||
};
|
||
t.exports = r
|
||
}, {}],
|
||
98: [function(e, t) {
|
||
(function(n) {
|
||
"use strict";
|
||
|
||
function r(e) {
|
||
"production" !== n.env.NODE_ENV ? p(a.isValidElement(e), "renderToString(): You must pass a valid ReactElement.") : p(a.isValidElement(e));
|
||
var t;
|
||
try {
|
||
var r = i.createReactRootID();
|
||
return t = u.getPooled(!1), t.perform(function() {
|
||
var n = l(e, null),
|
||
o = n.mountComponent(r, t, c);
|
||
return s.addChecksumToMarkup(o)
|
||
}, null)
|
||
} finally {
|
||
u.release(t)
|
||
}
|
||
}
|
||
|
||
function o(e) {
|
||
"production" !== n.env.NODE_ENV ? p(a.isValidElement(e), "renderToStaticMarkup(): You must pass a valid ReactElement.") : p(a.isValidElement(e));
|
||
var t;
|
||
try {
|
||
var r = i.createReactRootID();
|
||
return t = u.getPooled(!0), t.perform(function() {
|
||
var n = l(e, null);
|
||
return n.mountComponent(r, t, c)
|
||
}, null)
|
||
} finally {
|
||
u.release(t)
|
||
}
|
||
}
|
||
var a = e("./ReactElement"),
|
||
i = e("./ReactInstanceHandles"),
|
||
s = e("./ReactMarkupChecksum"),
|
||
u = e("./ReactServerRenderingTransaction"),
|
||
c = e("./emptyObject"),
|
||
l = e("./instantiateReactComponent"),
|
||
p = e("./invariant");
|
||
t.exports = {
|
||
renderToString: r,
|
||
renderToStaticMarkup: o
|
||
}
|
||
}).call(this, e("_process"))
|
||
}, {
|
||
"./ReactElement": 69,
|
||
"./ReactInstanceHandles": 78,
|
||
"./ReactMarkupChecksum": 82,
|
||
"./ReactServerRenderingTransaction": 99,
|
||
"./emptyObject": 137,
|
||
"./instantiateReactComponent": 156,
|
||
"./invariant": 157,
|
||
_process: 2
|
||
}],
|
||
99: [function(e, t) {
|
||
"use strict";
|
||
|
||
function n(e) {
|
||
this.reinitializeTransaction(), this.renderToStaticMarkup = e, this.reactMountReady = o.getPooled(null), this.putListenerQueue = a.getPooled()
|
||
}
|
||
var r = e("./PooledClass"),
|
||
o = e("./CallbackQueue"),
|
||
a = e("./ReactPutListenerQueue"),
|
||
i = e("./Transaction"),
|
||
s = e("./Object.assign"),
|
||
u = e("./emptyFunction"),
|
||
c = {
|
||
initialize: function() {
|
||
this.reactMountReady.reset()
|
||
},
|
||
close: u
|
||
},
|
||
l = {
|
||
initialize: function() {
|
||
this.putListenerQueue.reset()
|
||
},
|
||
close: u
|
||
},
|
||
p = [l, c],
|
||
d = {
|
||
getTransactionWrappers: function() {
|
||
return p
|
||
},
|
||
getReactMountReady: function() {
|
||
return this.reactMountReady
|
||
},
|
||
getPutListenerQueue: function() {
|
||
return this.putListenerQueue
|
||
},
|
||
destructor: function() {
|
||
o.release(this.reactMountReady), this.reactMountReady = null, a.release(this.putListenerQueue), this.putListenerQueue = null
|
||
}
|
||
};
|
||
s(n.prototype, i.Mixin, d), r.addPoolingTo(n), t.exports = n
|
||
}, {
|
||
"./CallbackQueue": 13,
|
||
"./Object.assign": 35,
|
||
"./PooledClass": 36,
|
||
"./ReactPutListenerQueue": 93,
|
||
"./Transaction": 123,
|
||
"./emptyFunction": 136
|
||
}],
|
||
100: [function(e, t) {
|
||
"use strict";
|
||
|
||
function n(e, t) {
|
||
var n = {};
|
||
return function(r) {
|
||
n[t] = r, e.setState(n)
|
||
}
|
||
}
|
||
var r = {
|
||
createStateSetter: function(e, t) {
|
||
return function(n, r, o, a, i, s) {
|
||
var u = t.call(e, n, r, o, a, i, s);
|
||
u && e.setState(u)
|
||
}
|
||
},
|
||
createStateKeySetter: function(e, t) {
|
||
var r = e.__keySetters || (e.__keySetters = {});
|
||
return r[t] || (r[t] = n(e, t))
|
||
}
|
||
};
|
||
r.Mixin = {
|
||
createStateSetter: function(e) {
|
||
return r.createStateSetter(this, e)
|
||
},
|
||
createStateKeySetter: function(e) {
|
||
return r.createStateKeySetter(this, e)
|
||
}
|
||
}, t.exports = r
|
||
}, {}],
|
||
101: [function(e, t) {
|
||
"use strict";
|
||
|
||
function n() {}
|
||
|
||
function r(e) {
|
||
return function(t, r) {
|
||
var o;
|
||
b.isDOMComponent(t) ? o = t.getDOMNode() : t.tagName && (o = t);
|
||
var a = new n;
|
||
a.target = o;
|
||
var i = new g(d.eventNameDispatchConfigs[e], m.getID(o), a);
|
||
E(i, r), u.accumulateTwoPhaseDispatches(i), y.batchedUpdates(function() {
|
||
s.enqueueEvents(i), s.processEventQueue()
|
||
})
|
||
}
|
||
}
|
||
|
||
function o() {
|
||
b.Simulate = {};
|
||
var e;
|
||
for (e in d.eventNameDispatchConfigs) b.Simulate[e] = r(e)
|
||
}
|
||
|
||
function a(e) {
|
||
return function(t, r) {
|
||
var o = new n(e);
|
||
E(o, r), b.isDOMComponent(t) ? b.simulateNativeEventOnDOMComponent(e, t, o) : t.tagName && b.simulateNativeEventOnNode(e, t, o)
|
||
}
|
||
}
|
||
var i = e("./EventConstants"),
|
||
s = e("./EventPluginHub"),
|
||
u = e("./EventPropagators"),
|
||
c = e("./React"),
|
||
l = e("./ReactElement"),
|
||
p = e("./ReactEmptyComponent"),
|
||
d = e("./ReactBrowserEventEmitter"),
|
||
f = e("./ReactCompositeComponent"),
|
||
h = e("./ReactInstanceHandles"),
|
||
v = e("./ReactInstanceMap"),
|
||
m = e("./ReactMount"),
|
||
y = e("./ReactUpdates"),
|
||
g = e("./SyntheticEvent"),
|
||
E = e("./Object.assign"),
|
||
C = i.topLevelTypes,
|
||
b = {
|
||
renderIntoDocument: function(e) {
|
||
var t = document.createElement("div");
|
||
return c.render(e, t)
|
||
},
|
||
isElement: function(e) {
|
||
return l.isValidElement(e)
|
||
},
|
||
isElementOfType: function(e, t) {
|
||
return l.isValidElement(e) && e.type === t
|
||
},
|
||
isDOMComponent: function(e) {
|
||
return !!(e && e.tagName && e.getDOMNode)
|
||
},
|
||
isDOMComponentElement: function(e) {
|
||
return !!(e && l.isValidElement(e) && e.tagName)
|
||
},
|
||
isCompositeComponent: function(e) {
|
||
return "function" == typeof e.render && "function" == typeof e.setState
|
||
},
|
||
isCompositeComponentWithType: function(e, t) {
|
||
return !(!b.isCompositeComponent(e) || e.constructor !== t)
|
||
},
|
||
isCompositeComponentElement: function(e) {
|
||
if (!l.isValidElement(e)) return !1;
|
||
var t = e.type.prototype;
|
||
return "function" == typeof t.render && "function" == typeof t.setState
|
||
},
|
||
isCompositeComponentElementWithType: function(e, t) {
|
||
return !(!b.isCompositeComponentElement(e) || e.constructor !== t)
|
||
},
|
||
getRenderedChildOfCompositeComponent: function(e) {
|
||
if (!b.isCompositeComponent(e)) return null;
|
||
var t = v.get(e);
|
||
return t._renderedComponent.getPublicInstance()
|
||
},
|
||
findAllInRenderedTree: function(e, t) {
|
||
if (!e) return [];
|
||
var n = t(e) ? [e] : [];
|
||
if (b.isDOMComponent(e)) {
|
||
var r, o = v.get(e),
|
||
a = o._renderedComponent._renderedChildren;
|
||
for (r in a) a.hasOwnProperty(r) && a[r].getPublicInstance && (n = n.concat(b.findAllInRenderedTree(a[r].getPublicInstance(), t)))
|
||
} else b.isCompositeComponent(e) && (n = n.concat(b.findAllInRenderedTree(b.getRenderedChildOfCompositeComponent(e), t)));
|
||
return n
|
||
},
|
||
scryRenderedDOMComponentsWithClass: function(e, t) {
|
||
return b.findAllInRenderedTree(e, function(e) {
|
||
var n = e.props.className;
|
||
return b.isDOMComponent(e) && n && -1 !== (" " + n + " ").indexOf(" " + t + " ")
|
||
})
|
||
},
|
||
findRenderedDOMComponentWithClass: function(e, t) {
|
||
var n = b.scryRenderedDOMComponentsWithClass(e, t);
|
||
if (1 !== n.length) throw new Error("Did not find exactly one match (found: " + n.length + ") for class:" + t);
|
||
return n[0]
|
||
},
|
||
scryRenderedDOMComponentsWithTag: function(e, t) {
|
||
return b.findAllInRenderedTree(e, function(e) {
|
||
return b.isDOMComponent(e) && e.tagName === t.toUpperCase()
|
||
})
|
||
},
|
||
findRenderedDOMComponentWithTag: function(e, t) {
|
||
var n = b.scryRenderedDOMComponentsWithTag(e, t);
|
||
if (1 !== n.length) throw new Error("Did not find exactly one match for tag:" + t);
|
||
return n[0]
|
||
},
|
||
scryRenderedComponentsWithType: function(e, t) {
|
||
return b.findAllInRenderedTree(e, function(e) {
|
||
return b.isCompositeComponentWithType(e, t)
|
||
})
|
||
},
|
||
findRenderedComponentWithType: function(e, t) {
|
||
var n = b.scryRenderedComponentsWithType(e, t);
|
||
if (1 !== n.length) throw new Error("Did not find exactly one match for componentType:" + t);
|
||
return n[0]
|
||
},
|
||
mockComponent: function(e, t) {
|
||
return t = t || e.mockTagName || "div", e.prototype.render.mockImplementation(function() {
|
||
return c.createElement(t, null, this.props.children)
|
||
}), this
|
||
},
|
||
simulateNativeEventOnNode: function(e, t, n) {
|
||
n.target = t, d.ReactEventListener.dispatchEvent(e, n)
|
||
},
|
||
simulateNativeEventOnDOMComponent: function(e, t, n) {
|
||
b.simulateNativeEventOnNode(e, t.getDOMNode(), n)
|
||
},
|
||
nativeTouchData: function(e, t) {
|
||
return {
|
||
touches: [{
|
||
pageX: e,
|
||
pageY: t
|
||
}]
|
||
}
|
||
},
|
||
createRenderer: function() {
|
||
return new _
|
||
},
|
||
Simulate: null,
|
||
SimulateNative: {}
|
||
},
|
||
_ = function() {
|
||
this._instance = null
|
||
};
|
||
_.prototype.getRenderOutput = function() {
|
||
return this._instance && this._instance._renderedComponent && this._instance._renderedComponent._renderedOutput || null
|
||
};
|
||
var N = function(e) {
|
||
this._renderedOutput = e, this._currentElement = null === e || e === !1 ? p.emptyElement : e
|
||
};
|
||
N.prototype = {
|
||
mountComponent: function() {},
|
||
receiveComponent: function(e) {
|
||
this._renderedOutput = e, this._currentElement = null === e || e === !1 ? p.emptyElement : e
|
||
},
|
||
unmountComponent: function() {}
|
||
};
|
||
var O = function() {};
|
||
E(O.prototype, f.Mixin, {
|
||
_instantiateReactComponent: function(e) {
|
||
return new N(e)
|
||
},
|
||
_replaceNodeWithMarkupByID: function() {},
|
||
_renderValidatedComponent: f.Mixin._renderValidatedComponentWithoutOwnerOrContext
|
||
}), _.prototype.render = function(e, t) {
|
||
var n = y.ReactReconcileTransaction.getPooled();
|
||
this._render(e, n, t), y.ReactReconcileTransaction.release(n)
|
||
}, _.prototype.unmount = function() {
|
||
this._instance && this._instance.unmountComponent()
|
||
}, _.prototype._render = function(e, t, n) {
|
||
if (this._instance) this._instance.receiveComponent(e, t, n);
|
||
else {
|
||
var r = h.createReactRootID(),
|
||
o = new O(e.type);
|
||
o.construct(e), o.mountComponent(r, t, n), this._instance = o
|
||
}
|
||
};
|
||
var R = s.injection.injectEventPluginOrder;
|
||
s.injection.injectEventPluginOrder = function() {
|
||
R.apply(this, arguments), o()
|
||
};
|
||
var D = s.injection.injectEventPluginsByName;
|
||
s.injection.injectEventPluginsByName = function() {
|
||
D.apply(this, arguments), o()
|
||
}, o();
|
||
var w;
|
||
for (w in C) {
|
||
var M = 0 === w.indexOf("top") ? w.charAt(3).toLowerCase() + w.substr(4) : w;
|
||
b.SimulateNative[M] = a(w)
|
||
}
|
||
t.exports = b
|
||
}, {
|
||
"./EventConstants": 22,
|
||
"./EventPluginHub": 24,
|
||
"./EventPropagators": 27,
|
||
"./Object.assign": 35,
|
||
"./React": 37,
|
||
"./ReactBrowserEventEmitter": 39,
|
||
"./ReactCompositeComponent": 49,
|
||
"./ReactElement": 69,
|
||
"./ReactEmptyComponent": 71,
|
||
"./ReactInstanceHandles": 78,
|
||
"./ReactInstanceMap": 79,
|
||
"./ReactMount": 83,
|
||
"./ReactUpdates": 106,
|
||
"./SyntheticEvent": 115
|
||
}],
|
||
102: [function(e, t) {
|
||
"use strict";
|
||
var n = e("./ReactChildren"),
|
||
r = e("./ReactFragment"),
|
||
o = {
|
||
getChildMapping: function(e) {
|
||
return e ? r.extract(n.map(e, function(e) {
|
||
return e
|
||
})) : e
|
||
},
|
||
mergeChildMappings: function(e, t) {
|
||
function n(n) {
|
||
return t.hasOwnProperty(n) ? t[n] : e[n]
|
||
}
|
||
e = e || {}, t = t || {};
|
||
var r = {},
|
||
o = [];
|
||
for (var a in e) t.hasOwnProperty(a) ? o.length && (r[a] = o, o = []) : o.push(a);
|
||
var i, s = {};
|
||
for (var u in t) {
|
||
if (r.hasOwnProperty(u))
|
||
for (i = 0; i < r[u].length; i++) {
|
||
var c = r[u][i];
|
||
s[r[u][i]] = n(c)
|
||
}
|
||
s[u] = n(u)
|
||
}
|
||
for (i = 0; i < o.length; i++) s[o[i]] = n(o[i]);
|
||
return s
|
||
}
|
||
};
|
||
t.exports = o
|
||
}, {
|
||
"./ReactChildren": 43,
|
||
"./ReactFragment": 75
|
||
}],
|
||
103: [function(e, t) {
|
||
"use strict";
|
||
|
||
function n() {
|
||
var e = document.createElement("div"),
|
||
t = e.style;
|
||
"AnimationEvent" in window || delete i.animationend.animation, "TransitionEvent" in window || delete i.transitionend.transition;
|
||
for (var n in i) {
|
||
var r = i[n];
|
||
for (var o in r)
|
||
if (o in t) {
|
||
s.push(r[o]);
|
||
break
|
||
}
|
||
}
|
||
}
|
||
|
||
function r(e, t, n) {
|
||
e.addEventListener(t, n, !1)
|
||
}
|
||
|
||
function o(e, t, n) {
|
||
e.removeEventListener(t, n, !1)
|
||
}
|
||
var a = e("./ExecutionEnvironment"),
|
||
i = {
|
||
transitionend: {
|
||
transition: "transitionend",
|
||
WebkitTransition: "webkitTransitionEnd",
|
||
MozTransition: "mozTransitionEnd",
|
||
OTransition: "oTransitionEnd",
|
||
msTransition: "MSTransitionEnd"
|
||
},
|
||
animationend: {
|
||
animation: "animationend",
|
||
WebkitAnimation: "webkitAnimationEnd",
|
||
MozAnimation: "mozAnimationEnd",
|
||
OAnimation: "oAnimationEnd",
|
||
msAnimation: "MSAnimationEnd"
|
||
}
|
||
},
|
||
s = [];
|
||
a.canUseDOM && n();
|
||
var u = {
|
||
addEndEventListener: function(e, t) {
|
||
return 0 === s.length ? void window.setTimeout(t, 0) : void s.forEach(function(n) {
|
||
r(e, n, t)
|
||
})
|
||
},
|
||
removeEndEventListener: function(e, t) {
|
||
0 !== s.length && s.forEach(function(n) {
|
||
o(e, n, t)
|
||
})
|
||
}
|
||
};
|
||
t.exports = u
|
||
}, {
|
||
"./ExecutionEnvironment": 28
|
||
}],
|
||
104: [function(e, t) {
|
||
"use strict";
|
||
var n = e("./React"),
|
||
r = e("./ReactTransitionChildMapping"),
|
||
o = e("./Object.assign"),
|
||
a = e("./cloneWithProps"),
|
||
i = e("./emptyFunction"),
|
||
s = n.createClass({
|
||
displayName: "ReactTransitionGroup",
|
||
propTypes: {
|
||
component: n.PropTypes.any,
|
||
childFactory: n.PropTypes.func
|
||
},
|
||
getDefaultProps: function() {
|
||
return {
|
||
component: "span",
|
||
childFactory: i.thatReturnsArgument
|
||
}
|
||
},
|
||
getInitialState: function() {
|
||
return {
|
||
children: r.getChildMapping(this.props.children)
|
||
}
|
||
},
|
||
componentWillMount: function() {
|
||
this.currentlyTransitioningKeys = {}, this.keysToEnter = [], this.keysToLeave = []
|
||
},
|
||
componentDidMount: function() {
|
||
var e = this.state.children;
|
||
for (var t in e) e[t] && this.performAppear(t)
|
||
},
|
||
componentWillReceiveProps: function(e) {
|
||
var t = r.getChildMapping(e.children),
|
||
n = this.state.children;
|
||
this.setState({
|
||
children: r.mergeChildMappings(n, t)
|
||
});
|
||
var o;
|
||
for (o in t) {
|
||
var a = n && n.hasOwnProperty(o);
|
||
!t[o] || a || this.currentlyTransitioningKeys[o] || this.keysToEnter.push(o)
|
||
}
|
||
for (o in n) {
|
||
var i = t && t.hasOwnProperty(o);
|
||
!n[o] || i || this.currentlyTransitioningKeys[o] || this.keysToLeave.push(o)
|
||
}
|
||
},
|
||
componentDidUpdate: function() {
|
||
var e = this.keysToEnter;
|
||
this.keysToEnter = [], e.forEach(this.performEnter);
|
||
var t = this.keysToLeave;
|
||
this.keysToLeave = [], t.forEach(this.performLeave)
|
||
},
|
||
performAppear: function(e) {
|
||
this.currentlyTransitioningKeys[e] = !0;
|
||
var t = this.refs[e];
|
||
t.componentWillAppear ? t.componentWillAppear(this._handleDoneAppearing.bind(this, e)) : this._handleDoneAppearing(e)
|
||
},
|
||
_handleDoneAppearing: function(e) {
|
||
var t = this.refs[e];
|
||
t.componentDidAppear && t.componentDidAppear(), delete this.currentlyTransitioningKeys[e];
|
||
var n = r.getChildMapping(this.props.children);
|
||
n && n.hasOwnProperty(e) || this.performLeave(e)
|
||
},
|
||
performEnter: function(e) {
|
||
this.currentlyTransitioningKeys[e] = !0;
|
||
var t = this.refs[e];
|
||
t.componentWillEnter ? t.componentWillEnter(this._handleDoneEntering.bind(this, e)) : this._handleDoneEntering(e)
|
||
},
|
||
_handleDoneEntering: function(e) {
|
||
var t = this.refs[e];
|
||
t.componentDidEnter && t.componentDidEnter(), delete this.currentlyTransitioningKeys[e];
|
||
var n = r.getChildMapping(this.props.children);
|
||
n && n.hasOwnProperty(e) || this.performLeave(e)
|
||
},
|
||
performLeave: function(e) {
|
||
this.currentlyTransitioningKeys[e] = !0;
|
||
var t = this.refs[e];
|
||
t.componentWillLeave ? t.componentWillLeave(this._handleDoneLeaving.bind(this, e)) : this._handleDoneLeaving(e)
|
||
},
|
||
_handleDoneLeaving: function(e) {
|
||
var t = this.refs[e];
|
||
t.componentDidLeave && t.componentDidLeave(), delete this.currentlyTransitioningKeys[e];
|
||
var n = r.getChildMapping(this.props.children);
|
||
if (n && n.hasOwnProperty(e)) this.performEnter(e);
|
||
else {
|
||
var a = o({}, this.state.children);
|
||
delete a[e], this.setState({
|
||
children: a
|
||
})
|
||
}
|
||
},
|
||
render: function() {
|
||
var e = [];
|
||
for (var t in this.state.children) {
|
||
var r = this.state.children[t];
|
||
r && e.push(a(this.props.childFactory(r), {
|
||
ref: t,
|
||
key: t
|
||
}))
|
||
}
|
||
return n.createElement(this.props.component, this.props, e)
|
||
}
|
||
});
|
||
t.exports = s
|
||
}, {
|
||
"./Object.assign": 35,
|
||
"./React": 37,
|
||
"./ReactTransitionChildMapping": 102,
|
||
"./cloneWithProps": 129,
|
||
"./emptyFunction": 136
|
||
}],
|
||
105: [function(e, t) {
|
||
(function(n) {
|
||
"use strict";
|
||
|
||
function r(e) {
|
||
e !== a.currentlyMountingInstance && c.enqueueUpdate(e)
|
||
}
|
||
|
||
function o(e, t) {
|
||
"production" !== n.env.NODE_ENV ? p(null == i.current, "%s(...): Cannot update during an existing state transition (such as within `render`). Render methods should be a pure function of props and state.", t) : p(null == i.current);
|
||
var r = u.get(e);
|
||
return r ? r === a.currentlyUnmountingInstance ? null : r : ("production" !== n.env.NODE_ENV && ("production" !== n.env.NODE_ENV ? d(!t, "%s(...): Can only update a mounted or mounting component. This usually means you called %s() on an unmounted component. This is a no-op.", t, t) : null), null)
|
||
}
|
||
var a = e("./ReactLifeCycle"),
|
||
i = e("./ReactCurrentOwner"),
|
||
s = e("./ReactElement"),
|
||
u = e("./ReactInstanceMap"),
|
||
c = e("./ReactUpdates"),
|
||
l = e("./Object.assign"),
|
||
p = e("./invariant"),
|
||
d = e("./warning"),
|
||
f = {
|
||
enqueueCallback: function(e, t) {
|
||
"production" !== n.env.NODE_ENV ? p("function" == typeof t, "enqueueCallback(...): You called `setProps`, `replaceProps`, `setState`, `replaceState`, or `forceUpdate` with a callback that isn't callable.") : p("function" == typeof t);
|
||
var i = o(e);
|
||
return i && i !== a.currentlyMountingInstance ? (i._pendingCallbacks ? i._pendingCallbacks.push(t) : i._pendingCallbacks = [t], void r(i)) : null
|
||
},
|
||
enqueueCallbackInternal: function(e, t) {
|
||
"production" !== n.env.NODE_ENV ? p("function" == typeof t, "enqueueCallback(...): You called `setProps`, `replaceProps`, `setState`, `replaceState`, or `forceUpdate` with a callback that isn't callable.") : p("function" == typeof t), e._pendingCallbacks ? e._pendingCallbacks.push(t) : e._pendingCallbacks = [t], r(e)
|
||
},
|
||
enqueueForceUpdate: function(e) {
|
||
var t = o(e, "forceUpdate");
|
||
t && (t._pendingForceUpdate = !0, r(t))
|
||
},
|
||
enqueueReplaceState: function(e, t) {
|
||
var n = o(e, "replaceState");
|
||
n && (n._pendingStateQueue = [t], n._pendingReplaceState = !0, r(n))
|
||
},
|
||
enqueueSetState: function(e, t) {
|
||
var n = o(e, "setState");
|
||
if (n) {
|
||
var a = n._pendingStateQueue || (n._pendingStateQueue = []);
|
||
a.push(t), r(n)
|
||
}
|
||
},
|
||
enqueueSetProps: function(e, t) {
|
||
var a = o(e, "setProps");
|
||
if (a) {
|
||
"production" !== n.env.NODE_ENV ? p(a._isTopLevel, "setProps(...): You called `setProps` on a component with a parent. This is an anti-pattern since props will get reactively updated when rendered. Instead, change the owner's `render` method to pass the correct value as props to the component where it is created.") : p(a._isTopLevel);
|
||
var i = a._pendingElement || a._currentElement,
|
||
u = l({}, i.props, t);
|
||
a._pendingElement = s.cloneAndReplaceProps(i, u), r(a)
|
||
}
|
||
},
|
||
enqueueReplaceProps: function(e, t) {
|
||
var a = o(e, "replaceProps");
|
||
if (a) {
|
||
"production" !== n.env.NODE_ENV ? p(a._isTopLevel, "replaceProps(...): You called `replaceProps` on a component with a parent. This is an anti-pattern since props will get reactively updated when rendered. Instead, change the owner's `render` method to pass the correct value as props to the component where it is created.") : p(a._isTopLevel);
|
||
var i = a._pendingElement || a._currentElement;
|
||
a._pendingElement = s.cloneAndReplaceProps(i, t), r(a)
|
||
}
|
||
},
|
||
enqueueElementInternal: function(e, t) {
|
||
e._pendingElement = t, r(e)
|
||
}
|
||
};
|
||
t.exports = f
|
||
}).call(this, e("_process"))
|
||
}, {
|
||
"./Object.assign": 35,
|
||
"./ReactCurrentOwner": 51,
|
||
"./ReactElement": 69,
|
||
"./ReactInstanceMap": 79,
|
||
"./ReactLifeCycle": 80,
|
||
"./ReactUpdates": 106,
|
||
"./invariant": 157,
|
||
"./warning": 178,
|
||
_process: 2
|
||
}],
|
||
106: [function(e, t) {
|
||
(function(n) {
|
||
"use strict";
|
||
|
||
function r() {
|
||
"production" !== n.env.NODE_ENV ? y(M.ReactReconcileTransaction && _, "ReactUpdates: must inject a reconcile transaction class and batching strategy") : y(M.ReactReconcileTransaction && _)
|
||
}
|
||
|
||
function o() {
|
||
this.reinitializeTransaction(), this.dirtyComponentsLength = null, this.callbackQueue = l.getPooled(), this.reconcileTransaction = M.ReactReconcileTransaction.getPooled()
|
||
}
|
||
|
||
function a(e, t, n, o, a) {
|
||
r(), _.batchedUpdates(e, t, n, o, a)
|
||
}
|
||
|
||
function i(e, t) {
|
||
return e._mountOrder - t._mountOrder
|
||
}
|
||
|
||
function s(e) {
|
||
var t = e.dirtyComponentsLength;
|
||
"production" !== n.env.NODE_ENV ? y(t === E.length, "Expected flush transaction's stored dirty-components length (%s) to match dirty-components array length (%s).", t, E.length) : y(t === E.length), E.sort(i);
|
||
for (var r = 0; t > r; r++) {
|
||
var o = E[r],
|
||
a = o._pendingCallbacks;
|
||
if (o._pendingCallbacks = null, h.performUpdateIfNecessary(o, e.reconcileTransaction), a)
|
||
for (var s = 0; s < a.length; s++) e.callbackQueue.enqueue(a[s], o.getPublicInstance())
|
||
}
|
||
}
|
||
|
||
function u(e) {
|
||
return r(), "production" !== n.env.NODE_ENV ? g(null == d.current, "enqueueUpdate(): Render methods should be a pure function of props and state; triggering nested component updates from render is not allowed. If necessary, trigger nested updates in componentDidUpdate.") : null, _.isBatchingUpdates ? void E.push(e) : void _.batchedUpdates(u, e)
|
||
}
|
||
|
||
function c(e, t) {
|
||
"production" !== n.env.NODE_ENV ? y(_.isBatchingUpdates, "ReactUpdates.asap: Can't enqueue an asap callback in a context whereupdates are not being batched.") : y(_.isBatchingUpdates), C.enqueue(e, t), b = !0
|
||
}
|
||
var l = e("./CallbackQueue"),
|
||
p = e("./PooledClass"),
|
||
d = e("./ReactCurrentOwner"),
|
||
f = e("./ReactPerf"),
|
||
h = e("./ReactReconciler"),
|
||
v = e("./Transaction"),
|
||
m = e("./Object.assign"),
|
||
y = e("./invariant"),
|
||
g = e("./warning"),
|
||
E = [],
|
||
C = l.getPooled(),
|
||
b = !1,
|
||
_ = null,
|
||
N = {
|
||
initialize: function() {
|
||
this.dirtyComponentsLength = E.length
|
||
},
|
||
close: function() {
|
||
this.dirtyComponentsLength !== E.length ? (E.splice(0, this.dirtyComponentsLength), D()) : E.length = 0
|
||
}
|
||
},
|
||
O = {
|
||
initialize: function() {
|
||
this.callbackQueue.reset()
|
||
},
|
||
close: function() {
|
||
this.callbackQueue.notifyAll()
|
||
}
|
||
},
|
||
R = [N, O];
|
||
m(o.prototype, v.Mixin, {
|
||
getTransactionWrappers: function() {
|
||
return R
|
||
},
|
||
destructor: function() {
|
||
this.dirtyComponentsLength = null, l.release(this.callbackQueue), this.callbackQueue = null, M.ReactReconcileTransaction.release(this.reconcileTransaction), this.reconcileTransaction = null
|
||
},
|
||
perform: function(e, t, n) {
|
||
return v.Mixin.perform.call(this, this.reconcileTransaction.perform, this.reconcileTransaction, e, t, n)
|
||
}
|
||
}), p.addPoolingTo(o);
|
||
var D = function() {
|
||
for (; E.length || b;) {
|
||
if (E.length) {
|
||
var e = o.getPooled();
|
||
e.perform(s, null, e), o.release(e)
|
||
}
|
||
if (b) {
|
||
b = !1;
|
||
var t = C;
|
||
C = l.getPooled(), t.notifyAll(), l.release(t)
|
||
}
|
||
}
|
||
};
|
||
D = f.measure("ReactUpdates", "flushBatchedUpdates", D);
|
||
var w = {
|
||
injectReconcileTransaction: function(e) {
|
||
"production" !== n.env.NODE_ENV ? y(e, "ReactUpdates: must provide a reconcile transaction class") : y(e), M.ReactReconcileTransaction = e
|
||
},
|
||
injectBatchingStrategy: function(e) {
|
||
"production" !== n.env.NODE_ENV ? y(e, "ReactUpdates: must provide a batching strategy") : y(e), "production" !== n.env.NODE_ENV ? y("function" == typeof e.batchedUpdates, "ReactUpdates: must provide a batchedUpdates() function") : y("function" == typeof e.batchedUpdates), "production" !== n.env.NODE_ENV ? y("boolean" == typeof e.isBatchingUpdates, "ReactUpdates: must provide an isBatchingUpdates boolean attribute") : y("boolean" == typeof e.isBatchingUpdates), _ = e
|
||
}
|
||
},
|
||
M = {
|
||
ReactReconcileTransaction: null,
|
||
batchedUpdates: a,
|
||
enqueueUpdate: u,
|
||
flushBatchedUpdates: D,
|
||
injection: w,
|
||
asap: c
|
||
};
|
||
t.exports = M
|
||
}).call(this, e("_process"))
|
||
}, {
|
||
"./CallbackQueue": 13,
|
||
"./Object.assign": 35,
|
||
"./PooledClass": 36,
|
||
"./ReactCurrentOwner": 51,
|
||
"./ReactPerf": 88,
|
||
"./ReactReconciler": 95,
|
||
"./Transaction": 123,
|
||
"./invariant": 157,
|
||
"./warning": 178,
|
||
_process: 2
|
||
}],
|
||
107: [function(e, t) {
|
||
(function(n) {
|
||
"use strict";
|
||
var r = e("./LinkedStateMixin"),
|
||
o = e("./React"),
|
||
a = e("./ReactComponentWithPureRenderMixin"),
|
||
i = e("./ReactCSSTransitionGroup"),
|
||
s = e("./ReactFragment"),
|
||
u = e("./ReactTransitionGroup"),
|
||
c = e("./ReactUpdates"),
|
||
l = e("./cx"),
|
||
p = e("./cloneWithProps"),
|
||
d = e("./update");
|
||
o.addons = {
|
||
CSSTransitionGroup: i,
|
||
LinkedStateMixin: r,
|
||
PureRenderMixin: a,
|
||
TransitionGroup: u,
|
||
batchedUpdates: c.batchedUpdates,
|
||
classSet: l,
|
||
cloneWithProps: p,
|
||
createFragment: s.create,
|
||
update: d
|
||
}, "production" !== n.env.NODE_ENV && (o.addons.Perf = e("./ReactDefaultPerf"), o.addons.TestUtils = e("./ReactTestUtils")), t.exports = o
|
||
}).call(this, e("_process"))
|
||
}, {
|
||
"./LinkedStateMixin": 31,
|
||
"./React": 37,
|
||
"./ReactCSSTransitionGroup": 40,
|
||
"./ReactComponentWithPureRenderMixin": 48,
|
||
"./ReactDefaultPerf": 67,
|
||
"./ReactFragment": 75,
|
||
"./ReactTestUtils": 101,
|
||
"./ReactTransitionGroup": 104,
|
||
"./ReactUpdates": 106,
|
||
"./cloneWithProps": 129,
|
||
"./cx": 134,
|
||
"./update": 177,
|
||
_process: 2
|
||
}],
|
||
108: [function(e, t) {
|
||
"use strict";
|
||
var n = e("./DOMProperty"),
|
||
r = n.injection.MUST_USE_ATTRIBUTE,
|
||
o = {
|
||
Properties: {
|
||
cx: r,
|
||
cy: r,
|
||
d: r,
|
||
dx: r,
|
||
dy: r,
|
||
fill: r,
|
||
fillOpacity: r,
|
||
fontFamily: r,
|
||
fontSize: r,
|
||
fx: r,
|
||
fy: r,
|
||
gradientTransform: r,
|
||
gradientUnits: r,
|
||
markerEnd: r,
|
||
markerMid: r,
|
||
markerStart: r,
|
||
offset: r,
|
||
opacity: r,
|
||
patternContentUnits: r,
|
||
patternUnits: r,
|
||
points: r,
|
||
preserveAspectRatio: r,
|
||
r: r,
|
||
rx: r,
|
||
ry: r,
|
||
spreadMethod: r,
|
||
stopColor: r,
|
||
stopOpacity: r,
|
||
stroke: r,
|
||
strokeDasharray: r,
|
||
strokeLinecap: r,
|
||
strokeOpacity: r,
|
||
strokeWidth: r,
|
||
textAnchor: r,
|
||
transform: r,
|
||
version: r,
|
||
viewBox: r,
|
||
x1: r,
|
||
x2: r,
|
||
x: r,
|
||
y1: r,
|
||
y2: r,
|
||
y: r
|
||
},
|
||
DOMAttributeNames: {
|
||
fillOpacity: "fill-opacity",
|
||
fontFamily: "font-family",
|
||
fontSize: "font-size",
|
||
gradientTransform: "gradientTransform",
|
||
gradientUnits: "gradientUnits",
|
||
markerEnd: "marker-end",
|
||
markerMid: "marker-mid",
|
||
markerStart: "marker-start",
|
||
patternContentUnits: "patternContentUnits",
|
||
patternUnits: "patternUnits",
|
||
preserveAspectRatio: "preserveAspectRatio",
|
||
spreadMethod: "spreadMethod",
|
||
stopColor: "stop-color",
|
||
stopOpacity: "stop-opacity",
|
||
strokeDasharray: "stroke-dasharray",
|
||
strokeLinecap: "stroke-linecap",
|
||
strokeOpacity: "stroke-opacity",
|
||
strokeWidth: "stroke-width",
|
||
textAnchor: "text-anchor",
|
||
viewBox: "viewBox"
|
||
}
|
||
};
|
||
t.exports = o
|
||
}, {
|
||
"./DOMProperty": 17
|
||
}],
|
||
109: [function(e, t) {
|
||
"use strict";
|
||
|
||
function n(e) {
|
||
if ("selectionStart" in e && i.hasSelectionCapabilities(e)) return {
|
||
start: e.selectionStart,
|
||
end: e.selectionEnd
|
||
};
|
||
if (window.getSelection) {
|
||
var t = window.getSelection();
|
||
return {
|
||
anchorNode: t.anchorNode,
|
||
anchorOffset: t.anchorOffset,
|
||
focusNode: t.focusNode,
|
||
focusOffset: t.focusOffset
|
||
}
|
||
}
|
||
if (document.selection) {
|
||
var n = document.selection.createRange();
|
||
return {
|
||
parentElement: n.parentElement(),
|
||
text: n.text,
|
||
top: n.boundingTop,
|
||
left: n.boundingLeft
|
||
}
|
||
}
|
||
}
|
||
|
||
function r(e) {
|
||
if (y || null == h || h !== u()) return null;
|
||
var t = n(h);
|
||
if (!m || !p(m, t)) {
|
||
m = t;
|
||
var r = s.getPooled(f.select, v, e);
|
||
return r.type = "select", r.target = h, a.accumulateTwoPhaseDispatches(r), r
|
||
}
|
||
}
|
||
var o = e("./EventConstants"),
|
||
a = e("./EventPropagators"),
|
||
i = e("./ReactInputSelection"),
|
||
s = e("./SyntheticEvent"),
|
||
u = e("./getActiveElement"),
|
||
c = e("./isTextInputElement"),
|
||
l = e("./keyOf"),
|
||
p = e("./shallowEqual"),
|
||
d = o.topLevelTypes,
|
||
f = {
|
||
select: {
|
||
phasedRegistrationNames: {
|
||
bubbled: l({
|
||
onSelect: null
|
||
}),
|
||
captured: l({
|
||
onSelectCapture: null
|
||
})
|
||
},
|
||
dependencies: [d.topBlur, d.topContextMenu, d.topFocus, d.topKeyDown, d.topMouseDown, d.topMouseUp, d.topSelectionChange]
|
||
}
|
||
},
|
||
h = null,
|
||
v = null,
|
||
m = null,
|
||
y = !1,
|
||
g = {
|
||
eventTypes: f,
|
||
extractEvents: function(e, t, n, o) {
|
||
switch (e) {
|
||
case d.topFocus:
|
||
(c(t) || "true" === t.contentEditable) && (h = t, v = n, m = null);
|
||
break;
|
||
case d.topBlur:
|
||
h = null, v = null, m = null;
|
||
break;
|
||
case d.topMouseDown:
|
||
y = !0;
|
||
break;
|
||
case d.topContextMenu:
|
||
case d.topMouseUp:
|
||
return y = !1, r(o);
|
||
case d.topSelectionChange:
|
||
case d.topKeyDown:
|
||
case d.topKeyUp:
|
||
return r(o)
|
||
}
|
||
}
|
||
};
|
||
t.exports = g
|
||
}, {
|
||
"./EventConstants": 22,
|
||
"./EventPropagators": 27,
|
||
"./ReactInputSelection": 77,
|
||
"./SyntheticEvent": 115,
|
||
"./getActiveElement": 143,
|
||
"./isTextInputElement": 160,
|
||
"./keyOf": 164,
|
||
"./shallowEqual": 173
|
||
}],
|
||
110: [function(e, t) {
|
||
"use strict";
|
||
var n = Math.pow(2, 53),
|
||
r = {
|
||
createReactRootIndex: function() {
|
||
return Math.ceil(Math.random() * n)
|
||
}
|
||
};
|
||
t.exports = r
|
||
}, {}],
|
||
111: [function(e, t) {
|
||
(function(n) {
|
||
"use strict";
|
||
var r = e("./EventConstants"),
|
||
o = e("./EventPluginUtils"),
|
||
a = e("./EventPropagators"),
|
||
i = e("./SyntheticClipboardEvent"),
|
||
s = e("./SyntheticEvent"),
|
||
u = e("./SyntheticFocusEvent"),
|
||
c = e("./SyntheticKeyboardEvent"),
|
||
l = e("./SyntheticMouseEvent"),
|
||
p = e("./SyntheticDragEvent"),
|
||
d = e("./SyntheticTouchEvent"),
|
||
f = e("./SyntheticUIEvent"),
|
||
h = e("./SyntheticWheelEvent"),
|
||
v = e("./getEventCharCode"),
|
||
m = e("./invariant"),
|
||
y = e("./keyOf"),
|
||
g = e("./warning"),
|
||
E = r.topLevelTypes,
|
||
C = {
|
||
blur: {
|
||
phasedRegistrationNames: {
|
||
bubbled: y({
|
||
onBlur: !0
|
||
}),
|
||
captured: y({
|
||
onBlurCapture: !0
|
||
})
|
||
}
|
||
},
|
||
click: {
|
||
phasedRegistrationNames: {
|
||
bubbled: y({
|
||
onClick: !0
|
||
}),
|
||
captured: y({
|
||
onClickCapture: !0
|
||
})
|
||
}
|
||
},
|
||
contextMenu: {
|
||
phasedRegistrationNames: {
|
||
bubbled: y({
|
||
onContextMenu: !0
|
||
}),
|
||
captured: y({
|
||
onContextMenuCapture: !0
|
||
})
|
||
}
|
||
},
|
||
copy: {
|
||
phasedRegistrationNames: {
|
||
bubbled: y({
|
||
onCopy: !0
|
||
}),
|
||
captured: y({
|
||
onCopyCapture: !0
|
||
})
|
||
}
|
||
},
|
||
cut: {
|
||
phasedRegistrationNames: {
|
||
bubbled: y({
|
||
onCut: !0
|
||
}),
|
||
captured: y({
|
||
onCutCapture: !0
|
||
})
|
||
}
|
||
},
|
||
doubleClick: {
|
||
phasedRegistrationNames: {
|
||
bubbled: y({
|
||
onDoubleClick: !0
|
||
}),
|
||
captured: y({
|
||
onDoubleClickCapture: !0
|
||
})
|
||
}
|
||
},
|
||
drag: {
|
||
phasedRegistrationNames: {
|
||
bubbled: y({
|
||
onDrag: !0
|
||
}),
|
||
captured: y({
|
||
onDragCapture: !0
|
||
})
|
||
}
|
||
},
|
||
dragEnd: {
|
||
phasedRegistrationNames: {
|
||
bubbled: y({
|
||
onDragEnd: !0
|
||
}),
|
||
captured: y({
|
||
onDragEndCapture: !0
|
||
})
|
||
}
|
||
},
|
||
dragEnter: {
|
||
phasedRegistrationNames: {
|
||
bubbled: y({
|
||
onDragEnter: !0
|
||
}),
|
||
captured: y({
|
||
onDragEnterCapture: !0
|
||
})
|
||
}
|
||
},
|
||
dragExit: {
|
||
phasedRegistrationNames: {
|
||
bubbled: y({
|
||
onDragExit: !0
|
||
}),
|
||
captured: y({
|
||
onDragExitCapture: !0
|
||
})
|
||
}
|
||
},
|
||
dragLeave: {
|
||
phasedRegistrationNames: {
|
||
bubbled: y({
|
||
onDragLeave: !0
|
||
}),
|
||
captured: y({
|
||
onDragLeaveCapture: !0
|
||
})
|
||
}
|
||
},
|
||
dragOver: {
|
||
phasedRegistrationNames: {
|
||
bubbled: y({
|
||
onDragOver: !0
|
||
}),
|
||
captured: y({
|
||
onDragOverCapture: !0
|
||
})
|
||
}
|
||
},
|
||
dragStart: {
|
||
phasedRegistrationNames: {
|
||
bubbled: y({
|
||
onDragStart: !0
|
||
}),
|
||
captured: y({
|
||
onDragStartCapture: !0
|
||
})
|
||
}
|
||
},
|
||
drop: {
|
||
phasedRegistrationNames: {
|
||
bubbled: y({
|
||
onDrop: !0
|
||
}),
|
||
captured: y({
|
||
onDropCapture: !0
|
||
})
|
||
}
|
||
},
|
||
focus: {
|
||
phasedRegistrationNames: {
|
||
bubbled: y({
|
||
onFocus: !0
|
||
}),
|
||
captured: y({
|
||
onFocusCapture: !0
|
||
})
|
||
}
|
||
},
|
||
input: {
|
||
phasedRegistrationNames: {
|
||
bubbled: y({
|
||
onInput: !0
|
||
}),
|
||
captured: y({
|
||
onInputCapture: !0
|
||
})
|
||
}
|
||
},
|
||
keyDown: {
|
||
phasedRegistrationNames: {
|
||
bubbled: y({
|
||
onKeyDown: !0
|
||
}),
|
||
captured: y({
|
||
onKeyDownCapture: !0
|
||
})
|
||
}
|
||
},
|
||
keyPress: {
|
||
phasedRegistrationNames: {
|
||
bubbled: y({
|
||
onKeyPress: !0
|
||
}),
|
||
captured: y({
|
||
onKeyPressCapture: !0
|
||
})
|
||
}
|
||
},
|
||
keyUp: {
|
||
phasedRegistrationNames: {
|
||
bubbled: y({
|
||
onKeyUp: !0
|
||
}),
|
||
captured: y({
|
||
onKeyUpCapture: !0
|
||
})
|
||
}
|
||
},
|
||
load: {
|
||
phasedRegistrationNames: {
|
||
bubbled: y({
|
||
onLoad: !0
|
||
}),
|
||
captured: y({
|
||
onLoadCapture: !0
|
||
})
|
||
}
|
||
},
|
||
error: {
|
||
phasedRegistrationNames: {
|
||
bubbled: y({
|
||
onError: !0
|
||
}),
|
||
captured: y({
|
||
onErrorCapture: !0
|
||
})
|
||
}
|
||
},
|
||
mouseDown: {
|
||
phasedRegistrationNames: {
|
||
bubbled: y({
|
||
onMouseDown: !0
|
||
}),
|
||
captured: y({
|
||
onMouseDownCapture: !0
|
||
})
|
||
}
|
||
},
|
||
mouseMove: {
|
||
phasedRegistrationNames: {
|
||
bubbled: y({
|
||
onMouseMove: !0
|
||
}),
|
||
captured: y({
|
||
onMouseMoveCapture: !0
|
||
})
|
||
}
|
||
},
|
||
mouseOut: {
|
||
phasedRegistrationNames: {
|
||
bubbled: y({
|
||
onMouseOut: !0
|
||
}),
|
||
captured: y({
|
||
onMouseOutCapture: !0
|
||
})
|
||
}
|
||
},
|
||
mouseOver: {
|
||
phasedRegistrationNames: {
|
||
bubbled: y({
|
||
onMouseOver: !0
|
||
}),
|
||
captured: y({
|
||
onMouseOverCapture: !0
|
||
})
|
||
}
|
||
},
|
||
mouseUp: {
|
||
phasedRegistrationNames: {
|
||
bubbled: y({
|
||
onMouseUp: !0
|
||
}),
|
||
captured: y({
|
||
onMouseUpCapture: !0
|
||
})
|
||
}
|
||
},
|
||
paste: {
|
||
phasedRegistrationNames: {
|
||
bubbled: y({
|
||
onPaste: !0
|
||
}),
|
||
captured: y({
|
||
onPasteCapture: !0
|
||
})
|
||
}
|
||
},
|
||
reset: {
|
||
phasedRegistrationNames: {
|
||
bubbled: y({
|
||
onReset: !0
|
||
}),
|
||
captured: y({
|
||
onResetCapture: !0
|
||
})
|
||
}
|
||
},
|
||
scroll: {
|
||
phasedRegistrationNames: {
|
||
bubbled: y({
|
||
onScroll: !0
|
||
}),
|
||
captured: y({
|
||
onScrollCapture: !0
|
||
})
|
||
}
|
||
},
|
||
submit: {
|
||
phasedRegistrationNames: {
|
||
bubbled: y({
|
||
onSubmit: !0
|
||
}),
|
||
captured: y({
|
||
onSubmitCapture: !0
|
||
})
|
||
}
|
||
},
|
||
touchCancel: {
|
||
phasedRegistrationNames: {
|
||
bubbled: y({
|
||
onTouchCancel: !0
|
||
}),
|
||
captured: y({
|
||
onTouchCancelCapture: !0
|
||
})
|
||
}
|
||
},
|
||
touchEnd: {
|
||
phasedRegistrationNames: {
|
||
bubbled: y({
|
||
onTouchEnd: !0
|
||
}),
|
||
captured: y({
|
||
onTouchEndCapture: !0
|
||
})
|
||
}
|
||
},
|
||
touchMove: {
|
||
phasedRegistrationNames: {
|
||
bubbled: y({
|
||
onTouchMove: !0
|
||
}),
|
||
captured: y({
|
||
onTouchMoveCapture: !0
|
||
})
|
||
}
|
||
},
|
||
touchStart: {
|
||
phasedRegistrationNames: {
|
||
bubbled: y({
|
||
onTouchStart: !0
|
||
}),
|
||
captured: y({
|
||
onTouchStartCapture: !0
|
||
})
|
||
}
|
||
},
|
||
wheel: {
|
||
phasedRegistrationNames: {
|
||
bubbled: y({
|
||
onWheel: !0
|
||
}),
|
||
captured: y({
|
||
onWheelCapture: !0
|
||
})
|
||
}
|
||
}
|
||
},
|
||
b = {
|
||
topBlur: C.blur,
|
||
topClick: C.click,
|
||
topContextMenu: C.contextMenu,
|
||
topCopy: C.copy,
|
||
topCut: C.cut,
|
||
topDoubleClick: C.doubleClick,
|
||
topDrag: C.drag,
|
||
topDragEnd: C.dragEnd,
|
||
topDragEnter: C.dragEnter,
|
||
topDragExit: C.dragExit,
|
||
topDragLeave: C.dragLeave,
|
||
topDragOver: C.dragOver,
|
||
topDragStart: C.dragStart,
|
||
topDrop: C.drop,
|
||
topError: C.error,
|
||
topFocus: C.focus,
|
||
topInput: C.input,
|
||
topKeyDown: C.keyDown,
|
||
topKeyPress: C.keyPress,
|
||
topKeyUp: C.keyUp,
|
||
topLoad: C.load,
|
||
topMouseDown: C.mouseDown,
|
||
topMouseMove: C.mouseMove,
|
||
topMouseOut: C.mouseOut,
|
||
topMouseOver: C.mouseOver,
|
||
topMouseUp: C.mouseUp,
|
||
topPaste: C.paste,
|
||
topReset: C.reset,
|
||
topScroll: C.scroll,
|
||
topSubmit: C.submit,
|
||
topTouchCancel: C.touchCancel,
|
||
topTouchEnd: C.touchEnd,
|
||
topTouchMove: C.touchMove,
|
||
topTouchStart: C.touchStart,
|
||
topWheel: C.wheel
|
||
};
|
||
for (var _ in b) b[_].dependencies = [_];
|
||
var N = {
|
||
eventTypes: C,
|
||
executeDispatch: function(e, t, r) {
|
||
var a = o.executeDispatch(e, t, r);
|
||
"production" !== n.env.NODE_ENV ? g("boolean" != typeof a, "Returning `false` from an event handler is deprecated and will be ignored in a future release. Instead, manually call e.stopPropagation() or e.preventDefault(), as appropriate.") : null, a === !1 && (e.stopPropagation(), e.preventDefault())
|
||
},
|
||
extractEvents: function(e, t, r, o) {
|
||
var y = b[e];
|
||
if (!y) return null;
|
||
var g;
|
||
switch (e) {
|
||
case E.topInput:
|
||
case E.topLoad:
|
||
case E.topError:
|
||
case E.topReset:
|
||
case E.topSubmit:
|
||
g = s;
|
||
break;
|
||
case E.topKeyPress:
|
||
if (0 === v(o)) return null;
|
||
case E.topKeyDown:
|
||
case E.topKeyUp:
|
||
g = c;
|
||
break;
|
||
case E.topBlur:
|
||
case E.topFocus:
|
||
g = u;
|
||
break;
|
||
case E.topClick:
|
||
if (2 === o.button) return null;
|
||
case E.topContextMenu:
|
||
case E.topDoubleClick:
|
||
case E.topMouseDown:
|
||
case E.topMouseMove:
|
||
case E.topMouseOut:
|
||
case E.topMouseOver:
|
||
case E.topMouseUp:
|
||
g = l;
|
||
break;
|
||
case E.topDrag:
|
||
case E.topDragEnd:
|
||
case E.topDragEnter:
|
||
case E.topDragExit:
|
||
case E.topDragLeave:
|
||
case E.topDragOver:
|
||
case E.topDragStart:
|
||
case E.topDrop:
|
||
g = p;
|
||
break;
|
||
case E.topTouchCancel:
|
||
case E.topTouchEnd:
|
||
case E.topTouchMove:
|
||
case E.topTouchStart:
|
||
g = d;
|
||
break;
|
||
case E.topScroll:
|
||
g = f;
|
||
break;
|
||
case E.topWheel:
|
||
g = h;
|
||
break;
|
||
case E.topCopy:
|
||
case E.topCut:
|
||
case E.topPaste:
|
||
g = i
|
||
}
|
||
"production" !== n.env.NODE_ENV ? m(g, "SimpleEventPlugin: Unhandled event type, `%s`.", e) : m(g);
|
||
var C = g.getPooled(y, r, o);
|
||
return a.accumulateTwoPhaseDispatches(C), C
|
||
}
|
||
};
|
||
t.exports = N
|
||
}).call(this, e("_process"))
|
||
}, {
|
||
"./EventConstants": 22,
|
||
"./EventPluginUtils": 26,
|
||
"./EventPropagators": 27,
|
||
"./SyntheticClipboardEvent": 112,
|
||
"./SyntheticDragEvent": 114,
|
||
"./SyntheticEvent": 115,
|
||
"./SyntheticFocusEvent": 116,
|
||
"./SyntheticKeyboardEvent": 118,
|
||
"./SyntheticMouseEvent": 119,
|
||
"./SyntheticTouchEvent": 120,
|
||
"./SyntheticUIEvent": 121,
|
||
"./SyntheticWheelEvent": 122,
|
||
"./getEventCharCode": 144,
|
||
"./invariant": 157,
|
||
"./keyOf": 164,
|
||
"./warning": 178,
|
||
_process: 2
|
||
}],
|
||
112: [function(e, t) {
|
||
"use strict";
|
||
|
||
function n(e, t, n) {
|
||
r.call(this, e, t, n)
|
||
}
|
||
var r = e("./SyntheticEvent"),
|
||
o = {
|
||
clipboardData: function(e) {
|
||
return "clipboardData" in e ? e.clipboardData : window.clipboardData
|
||
}
|
||
};
|
||
r.augmentClass(n, o), t.exports = n
|
||
}, {
|
||
"./SyntheticEvent": 115
|
||
}],
|
||
113: [function(e, t) {
|
||
"use strict";
|
||
|
||
function n(e, t, n) {
|
||
r.call(this, e, t, n)
|
||
}
|
||
var r = e("./SyntheticEvent"),
|
||
o = {
|
||
data: null
|
||
};
|
||
r.augmentClass(n, o), t.exports = n
|
||
}, {
|
||
"./SyntheticEvent": 115
|
||
}],
|
||
114: [function(e, t) {
|
||
"use strict";
|
||
|
||
function n(e, t, n) {
|
||
r.call(this, e, t, n)
|
||
}
|
||
var r = e("./SyntheticMouseEvent"),
|
||
o = {
|
||
dataTransfer: null
|
||
};
|
||
r.augmentClass(n, o), t.exports = n
|
||
}, {
|
||
"./SyntheticMouseEvent": 119
|
||
}],
|
||
115: [function(e, t) {
|
||
"use strict";
|
||
|
||
function n(e, t, n) {
|
||
this.dispatchConfig = e, this.dispatchMarker = t, this.nativeEvent = n;
|
||
var r = this.constructor.Interface;
|
||
for (var o in r)
|
||
if (r.hasOwnProperty(o)) {
|
||
var i = r[o];
|
||
this[o] = i ? i(n) : n[o]
|
||
} var s = null != n.defaultPrevented ? n.defaultPrevented : n.returnValue === !1;
|
||
this.isDefaultPrevented = s ? a.thatReturnsTrue : a.thatReturnsFalse, this.isPropagationStopped = a.thatReturnsFalse
|
||
}
|
||
var r = e("./PooledClass"),
|
||
o = e("./Object.assign"),
|
||
a = e("./emptyFunction"),
|
||
i = e("./getEventTarget"),
|
||
s = {
|
||
type: null,
|
||
target: i,
|
||
currentTarget: a.thatReturnsNull,
|
||
eventPhase: null,
|
||
bubbles: null,
|
||
cancelable: null,
|
||
timeStamp: function(e) {
|
||
return e.timeStamp || Date.now()
|
||
},
|
||
defaultPrevented: null,
|
||
isTrusted: null
|
||
};
|
||
o(n.prototype, {
|
||
preventDefault: function() {
|
||
this.defaultPrevented = !0;
|
||
var e = this.nativeEvent;
|
||
e.preventDefault ? e.preventDefault() : e.returnValue = !1, this.isDefaultPrevented = a.thatReturnsTrue
|
||
},
|
||
stopPropagation: function() {
|
||
var e = this.nativeEvent;
|
||
e.stopPropagation ? e.stopPropagation() : e.cancelBubble = !0, this.isPropagationStopped = a.thatReturnsTrue
|
||
},
|
||
persist: function() {
|
||
this.isPersistent = a.thatReturnsTrue
|
||
},
|
||
isPersistent: a.thatReturnsFalse,
|
||
destructor: function() {
|
||
var e = this.constructor.Interface;
|
||
for (var t in e) this[t] = null;
|
||
this.dispatchConfig = null, this.dispatchMarker = null, this.nativeEvent = null
|
||
}
|
||
}), n.Interface = s, n.augmentClass = function(e, t) {
|
||
var n = this,
|
||
a = Object.create(n.prototype);
|
||
o(a, e.prototype), e.prototype = a, e.prototype.constructor = e, e.Interface = o({}, n.Interface, t), e.augmentClass = n.augmentClass, r.addPoolingTo(e, r.threeArgumentPooler)
|
||
}, r.addPoolingTo(n, r.threeArgumentPooler), t.exports = n
|
||
}, {
|
||
"./Object.assign": 35,
|
||
"./PooledClass": 36,
|
||
"./emptyFunction": 136,
|
||
"./getEventTarget": 147
|
||
}],
|
||
116: [function(e, t) {
|
||
"use strict";
|
||
|
||
function n(e, t, n) {
|
||
r.call(this, e, t, n)
|
||
}
|
||
var r = e("./SyntheticUIEvent"),
|
||
o = {
|
||
relatedTarget: null
|
||
};
|
||
r.augmentClass(n, o), t.exports = n
|
||
}, {
|
||
"./SyntheticUIEvent": 121
|
||
}],
|
||
117: [function(e, t) {
|
||
"use strict";
|
||
|
||
function n(e, t, n) {
|
||
r.call(this, e, t, n)
|
||
}
|
||
var r = e("./SyntheticEvent"),
|
||
o = {
|
||
data: null
|
||
};
|
||
r.augmentClass(n, o), t.exports = n
|
||
}, {
|
||
"./SyntheticEvent": 115
|
||
}],
|
||
118: [function(e, t) {
|
||
"use strict";
|
||
|
||
function n(e, t, n) {
|
||
r.call(this, e, t, n)
|
||
}
|
||
var r = e("./SyntheticUIEvent"),
|
||
o = e("./getEventCharCode"),
|
||
a = e("./getEventKey"),
|
||
i = e("./getEventModifierState"),
|
||
s = {
|
||
key: a,
|
||
location: null,
|
||
ctrlKey: null,
|
||
shiftKey: null,
|
||
altKey: null,
|
||
metaKey: null,
|
||
repeat: null,
|
||
locale: null,
|
||
getModifierState: i,
|
||
charCode: function(e) {
|
||
return "keypress" === e.type ? o(e) : 0
|
||
},
|
||
keyCode: function(e) {
|
||
return "keydown" === e.type || "keyup" === e.type ? e.keyCode : 0
|
||
},
|
||
which: function(e) {
|
||
return "keypress" === e.type ? o(e) : "keydown" === e.type || "keyup" === e.type ? e.keyCode : 0
|
||
}
|
||
};
|
||
r.augmentClass(n, s), t.exports = n
|
||
}, {
|
||
"./SyntheticUIEvent": 121,
|
||
"./getEventCharCode": 144,
|
||
"./getEventKey": 145,
|
||
"./getEventModifierState": 146
|
||
}],
|
||
119: [function(e, t) {
|
||
"use strict";
|
||
|
||
function n(e, t, n) {
|
||
r.call(this, e, t, n)
|
||
}
|
||
var r = e("./SyntheticUIEvent"),
|
||
o = e("./ViewportMetrics"),
|
||
a = e("./getEventModifierState"),
|
||
i = {
|
||
screenX: null,
|
||
screenY: null,
|
||
clientX: null,
|
||
clientY: null,
|
||
ctrlKey: null,
|
||
shiftKey: null,
|
||
altKey: null,
|
||
metaKey: null,
|
||
getModifierState: a,
|
||
button: function(e) {
|
||
var t = e.button;
|
||
return "which" in e ? t : 2 === t ? 2 : 4 === t ? 1 : 0
|
||
},
|
||
buttons: null,
|
||
relatedTarget: function(e) {
|
||
return e.relatedTarget || (e.fromElement === e.srcElement ? e.toElement : e.fromElement)
|
||
},
|
||
pageX: function(e) {
|
||
return "pageX" in e ? e.pageX : e.clientX + o.currentScrollLeft
|
||
},
|
||
pageY: function(e) {
|
||
return "pageY" in e ? e.pageY : e.clientY + o.currentScrollTop
|
||
}
|
||
};
|
||
r.augmentClass(n, i), t.exports = n
|
||
}, {
|
||
"./SyntheticUIEvent": 121,
|
||
"./ViewportMetrics": 124,
|
||
"./getEventModifierState": 146
|
||
}],
|
||
120: [function(e, t) {
|
||
"use strict";
|
||
|
||
function n(e, t, n) {
|
||
r.call(this, e, t, n)
|
||
}
|
||
var r = e("./SyntheticUIEvent"),
|
||
o = e("./getEventModifierState"),
|
||
a = {
|
||
touches: null,
|
||
targetTouches: null,
|
||
changedTouches: null,
|
||
altKey: null,
|
||
metaKey: null,
|
||
ctrlKey: null,
|
||
shiftKey: null,
|
||
getModifierState: o
|
||
};
|
||
r.augmentClass(n, a), t.exports = n
|
||
}, {
|
||
"./SyntheticUIEvent": 121,
|
||
"./getEventModifierState": 146
|
||
}],
|
||
121: [function(e, t) {
|
||
"use strict";
|
||
|
||
function n(e, t, n) {
|
||
r.call(this, e, t, n)
|
||
}
|
||
var r = e("./SyntheticEvent"),
|
||
o = e("./getEventTarget"),
|
||
a = {
|
||
view: function(e) {
|
||
if (e.view) return e.view;
|
||
var t = o(e);
|
||
if (null != t && t.window === t) return t;
|
||
var n = t.ownerDocument;
|
||
return n ? n.defaultView || n.parentWindow : window
|
||
},
|
||
detail: function(e) {
|
||
return e.detail || 0
|
||
}
|
||
};
|
||
r.augmentClass(n, a), t.exports = n
|
||
}, {
|
||
"./SyntheticEvent": 115,
|
||
"./getEventTarget": 147
|
||
}],
|
||
122: [function(e, t) {
|
||
"use strict";
|
||
|
||
function n(e, t, n) {
|
||
r.call(this, e, t, n)
|
||
}
|
||
var r = e("./SyntheticMouseEvent"),
|
||
o = {
|
||
deltaX: function(e) {
|
||
return "deltaX" in e ? e.deltaX : "wheelDeltaX" in e ? -e.wheelDeltaX : 0
|
||
},
|
||
deltaY: function(e) {
|
||
return "deltaY" in e ? e.deltaY : "wheelDeltaY" in e ? -e.wheelDeltaY : "wheelDelta" in e ? -e.wheelDelta : 0
|
||
},
|
||
deltaZ: null,
|
||
deltaMode: null
|
||
};
|
||
r.augmentClass(n, o), t.exports = n
|
||
}, {
|
||
"./SyntheticMouseEvent": 119
|
||
}],
|
||
123: [function(e, t) {
|
||
(function(n) {
|
||
"use strict";
|
||
var r = e("./invariant"),
|
||
o = {
|
||
reinitializeTransaction: function() {
|
||
this.transactionWrappers = this.getTransactionWrappers(), this.wrapperInitData ? this.wrapperInitData.length = 0 : this.wrapperInitData = [], this._isInTransaction = !1
|
||
},
|
||
_isInTransaction: !1,
|
||
getTransactionWrappers: null,
|
||
isInTransaction: function() {
|
||
return !!this._isInTransaction
|
||
},
|
||
perform: function(e, t, o, a, i, s, u, c) {
|
||
"production" !== n.env.NODE_ENV ? r(!this.isInTransaction(), "Transaction.perform(...): Cannot initialize a transaction when there is already an outstanding transaction.") : r(!this.isInTransaction());
|
||
var l, p;
|
||
try {
|
||
this._isInTransaction = !0, l = !0, this.initializeAll(0), p = e.call(t, o, a, i, s, u, c), l = !1
|
||
} finally {
|
||
try {
|
||
if (l) try {
|
||
this.closeAll(0)
|
||
} catch (d) {} else this.closeAll(0)
|
||
} finally {
|
||
this._isInTransaction = !1
|
||
}
|
||
}
|
||
return p
|
||
},
|
||
initializeAll: function(e) {
|
||
for (var t = this.transactionWrappers, n = e; n < t.length; n++) {
|
||
var r = t[n];
|
||
try {
|
||
this.wrapperInitData[n] = a.OBSERVED_ERROR, this.wrapperInitData[n] = r.initialize ? r.initialize.call(this) : null
|
||
} finally {
|
||
if (this.wrapperInitData[n] === a.OBSERVED_ERROR) try {
|
||
this.initializeAll(n + 1)
|
||
} catch (o) {}
|
||
}
|
||
}
|
||
},
|
||
closeAll: function(e) {
|
||
"production" !== n.env.NODE_ENV ? r(this.isInTransaction(), "Transaction.closeAll(): Cannot close transaction when none are open.") : r(this.isInTransaction());
|
||
for (var t = this.transactionWrappers, o = e; o < t.length; o++) {
|
||
var i, s = t[o],
|
||
u = this.wrapperInitData[o];
|
||
try {
|
||
i = !0, u !== a.OBSERVED_ERROR && s.close && s.close.call(this, u), i = !1
|
||
} finally {
|
||
if (i) try {
|
||
this.closeAll(o + 1)
|
||
} catch (c) {}
|
||
}
|
||
}
|
||
this.wrapperInitData.length = 0
|
||
}
|
||
},
|
||
a = {
|
||
Mixin: o,
|
||
OBSERVED_ERROR: {}
|
||
};
|
||
t.exports = a
|
||
}).call(this, e("_process"))
|
||
}, {
|
||
"./invariant": 157,
|
||
_process: 2
|
||
}],
|
||
124: [function(e, t) {
|
||
"use strict";
|
||
var n = {
|
||
currentScrollLeft: 0,
|
||
currentScrollTop: 0,
|
||
refreshScrollValues: function(e) {
|
||
n.currentScrollLeft = e.x, n.currentScrollTop = e.y
|
||
}
|
||
};
|
||
t.exports = n
|
||
}, {}],
|
||
125: [function(e, t) {
|
||
(function(n) {
|
||
"use strict";
|
||
|
||
function r(e, t) {
|
||
if ("production" !== n.env.NODE_ENV ? o(null != t, "accumulateInto(...): Accumulated items must not be null or undefined.") : o(null != t), null == e) return t;
|
||
var r = Array.isArray(e),
|
||
a = Array.isArray(t);
|
||
return r && a ? (e.push.apply(e, t), e) : r ? (e.push(t), e) : a ? [e].concat(t) : [e, t]
|
||
}
|
||
var o = e("./invariant");
|
||
t.exports = r
|
||
}).call(this, e("_process"))
|
||
}, {
|
||
"./invariant": 157,
|
||
_process: 2
|
||
}],
|
||
126: [function(e, t) {
|
||
"use strict";
|
||
|
||
function n(e) {
|
||
for (var t = 1, n = 0, o = 0; o < e.length; o++) t = (t + e.charCodeAt(o)) % r, n = (n + t) % r;
|
||
return t | n << 16
|
||
}
|
||
var r = 65521;
|
||
t.exports = n
|
||
}, {}],
|
||
127: [function(e, t) {
|
||
function n(e) {
|
||
return e.replace(r, function(e, t) {
|
||
return t.toUpperCase()
|
||
})
|
||
}
|
||
var r = /-(.)/g;
|
||
t.exports = n
|
||
}, {}],
|
||
128: [function(e, t) {
|
||
"use strict";
|
||
|
||
function n(e) {
|
||
return r(e.replace(o, "ms-"))
|
||
}
|
||
var r = e("./camelize"),
|
||
o = /^-ms-/;
|
||
t.exports = n
|
||
}, {
|
||
"./camelize": 127
|
||
}],
|
||
129: [function(e, t) {
|
||
(function(n) {
|
||
"use strict";
|
||
|
||
function r(e, t) {
|
||
"production" !== n.env.NODE_ENV && ("production" !== n.env.NODE_ENV ? s(!e.ref, "You are calling cloneWithProps() on a child with a ref. This is dangerous because you're creating a new child which will not be added as a ref to its parent.") : null);
|
||
var r = a.mergeProps(t, e.props);
|
||
return !r.hasOwnProperty(u) && e.props.hasOwnProperty(u) && (r.children = e.props.children), o.createElement(e.type, r)
|
||
}
|
||
var o = e("./ReactElement"),
|
||
a = e("./ReactPropTransferer"),
|
||
i = e("./keyOf"),
|
||
s = e("./warning"),
|
||
u = i({
|
||
children: null
|
||
});
|
||
t.exports = r
|
||
}).call(this, e("_process"))
|
||
}, {
|
||
"./ReactElement": 69,
|
||
"./ReactPropTransferer": 89,
|
||
"./keyOf": 164,
|
||
"./warning": 178,
|
||
_process: 2
|
||
}],
|
||
130: [function(e, t) {
|
||
function n(e, t) {
|
||
return e && t ? e === t ? !0 : r(e) ? !1 : r(t) ? n(e, t.parentNode) : e.contains ? e.contains(t) : e.compareDocumentPosition ? !!(16 & e.compareDocumentPosition(t)) : !1 : !1
|
||
}
|
||
var r = e("./isTextNode");
|
||
t.exports = n
|
||
}, {
|
||
"./isTextNode": 161
|
||
}],
|
||
131: [function(e, t) {
|
||
function n(e) {
|
||
return !!e && ("object" == typeof e || "function" == typeof e) && "length" in e && !("setInterval" in e) && "number" != typeof e.nodeType && (Array.isArray(e) || "callee" in e || "item" in e)
|
||
}
|
||
|
||
function r(e) {
|
||
return n(e) ? Array.isArray(e) ? e.slice() : o(e) : [e]
|
||
}
|
||
var o = e("./toArray");
|
||
t.exports = r
|
||
}, {
|
||
"./toArray": 175
|
||
}],
|
||
132: [function(e, t) {
|
||
(function(n) {
|
||
"use strict";
|
||
|
||
function r(e) {
|
||
var t = a.createFactory(e),
|
||
r = o.createClass({
|
||
tagName: e.toUpperCase(),
|
||
displayName: "ReactFullPageComponent" + e,
|
||
componentWillUnmount: function() {
|
||
"production" !== n.env.NODE_ENV ? i(!1, "%s tried to unmount. Because of cross-browser quirks it is impossible to unmount some top-level components (eg <html>, <head>, and <body>) reliably and efficiently. To fix this, have a single top-level component that never unmounts render these elements.", this.constructor.displayName) : i(!1)
|
||
},
|
||
render: function() {
|
||
return t(this.props)
|
||
}
|
||
});
|
||
return r
|
||
}
|
||
var o = e("./ReactClass"),
|
||
a = e("./ReactElement"),
|
||
i = e("./invariant");
|
||
t.exports = r
|
||
}).call(this, e("_process"))
|
||
}, {
|
||
"./ReactClass": 44,
|
||
"./ReactElement": 69,
|
||
"./invariant": 157,
|
||
_process: 2
|
||
}],
|
||
133: [function(e, t) {
|
||
(function(n) {
|
||
function r(e) {
|
||
var t = e.match(l);
|
||
return t && t[1].toLowerCase()
|
||
}
|
||
|
||
function o(e, t) {
|
||
var o = c;
|
||
"production" !== n.env.NODE_ENV ? u(!!c, "createNodesFromMarkup dummy not initialized") : u(!!c);
|
||
var a = r(e),
|
||
l = a && s(a);
|
||
if (l) {
|
||
o.innerHTML = l[1] + e + l[2];
|
||
for (var p = l[0]; p--;) o = o.lastChild
|
||
} else o.innerHTML = e;
|
||
var d = o.getElementsByTagName("script");
|
||
d.length && ("production" !== n.env.NODE_ENV ? u(t, "createNodesFromMarkup(...): Unexpected <script> element rendered.") : u(t), i(d).forEach(t));
|
||
for (var f = i(o.childNodes); o.lastChild;) o.removeChild(o.lastChild);
|
||
return f
|
||
}
|
||
var a = e("./ExecutionEnvironment"),
|
||
i = e("./createArrayFromMixed"),
|
||
s = e("./getMarkupWrap"),
|
||
u = e("./invariant"),
|
||
c = a.canUseDOM ? document.createElement("div") : null,
|
||
l = /^\s*<(\w+)/;
|
||
|
||
t.exports = o
|
||
}).call(this, e("_process"))
|
||
}, {
|
||
"./ExecutionEnvironment": 28,
|
||
"./createArrayFromMixed": 131,
|
||
"./getMarkupWrap": 149,
|
||
"./invariant": 157,
|
||
_process: 2
|
||
}],
|
||
134: [function(e, t) {
|
||
(function(n) {
|
||
"use strict";
|
||
|
||
function r(e) {
|
||
return "production" !== n.env.NODE_ENV && ("production" !== n.env.NODE_ENV ? o(a, "React.addons.classSet will be deprecated in a future version. See http://fb.me/react-addons-classset") : null, a = !0), "object" == typeof e ? Object.keys(e).filter(function(t) {
|
||
return e[t]
|
||
}).join(" ") : Array.prototype.join.call(arguments, " ")
|
||
}
|
||
var o = e("./warning"),
|
||
a = !1;
|
||
t.exports = r
|
||
}).call(this, e("_process"))
|
||
}, {
|
||
"./warning": 178,
|
||
_process: 2
|
||
}],
|
||
135: [function(e, t) {
|
||
"use strict";
|
||
|
||
function n(e, t) {
|
||
var n = null == t || "boolean" == typeof t || "" === t;
|
||
if (n) return "";
|
||
var r = isNaN(t);
|
||
return r || 0 === t || o.hasOwnProperty(e) && o[e] ? "" + t : ("string" == typeof t && (t = t.trim()), t + "px")
|
||
}
|
||
var r = e("./CSSProperty"),
|
||
o = r.isUnitlessNumber;
|
||
t.exports = n
|
||
}, {
|
||
"./CSSProperty": 11
|
||
}],
|
||
136: [function(e, t) {
|
||
function n(e) {
|
||
return function() {
|
||
return e
|
||
}
|
||
}
|
||
|
||
function r() {}
|
||
r.thatReturns = n, r.thatReturnsFalse = n(!1), r.thatReturnsTrue = n(!0), r.thatReturnsNull = n(null), r.thatReturnsThis = function() {
|
||
return this
|
||
}, r.thatReturnsArgument = function(e) {
|
||
return e
|
||
}, t.exports = r
|
||
}, {}],
|
||
137: [function(e, t) {
|
||
(function(e) {
|
||
"use strict";
|
||
var n = {};
|
||
"production" !== e.env.NODE_ENV && Object.freeze(n), t.exports = n
|
||
}).call(this, e("_process"))
|
||
}, {
|
||
_process: 2
|
||
}],
|
||
138: [function(e, t) {
|
||
"use strict";
|
||
|
||
function n(e) {
|
||
return o[e]
|
||
}
|
||
|
||
function r(e) {
|
||
return ("" + e).replace(a, n)
|
||
}
|
||
var o = {
|
||
"&": "&",
|
||
">": ">",
|
||
"<": "<",
|
||
'"': """,
|
||
"'": "'"
|
||
},
|
||
a = /[&><"']/g;
|
||
t.exports = r
|
||
}, {}],
|
||
139: [function(e, t) {
|
||
(function(n) {
|
||
"use strict";
|
||
|
||
function r(e) {
|
||
if ("production" !== n.env.NODE_ENV) {
|
||
var t = o.current;
|
||
null !== t && ("production" !== n.env.NODE_ENV ? c(t._warnedAboutRefsInRender, "%s is accessing getDOMNode or findDOMNode inside its render(). 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.", t.getName() || "A component") : null, t._warnedAboutRefsInRender = !0)
|
||
}
|
||
return null == e ? null : u(e) ? e : a.has(e) ? i.getNodeFromInstance(e) : ("production" !== n.env.NODE_ENV ? s(null == e.render || "function" != typeof e.render, "Component (with keys: %s) contains `render` method but is not mounted in the DOM", Object.keys(e)) : s(null == e.render || "function" != typeof e.render), void("production" !== n.env.NODE_ENV ? s(!1, "Element appears to be neither ReactComponent nor DOMNode (keys: %s)", Object.keys(e)) : s(!1)))
|
||
}
|
||
var o = e("./ReactCurrentOwner"),
|
||
a = e("./ReactInstanceMap"),
|
||
i = e("./ReactMount"),
|
||
s = e("./invariant"),
|
||
u = e("./isNode"),
|
||
c = e("./warning");
|
||
t.exports = r
|
||
}).call(this, e("_process"))
|
||
}, {
|
||
"./ReactCurrentOwner": 51,
|
||
"./ReactInstanceMap": 79,
|
||
"./ReactMount": 83,
|
||
"./invariant": 157,
|
||
"./isNode": 159,
|
||
"./warning": 178,
|
||
_process: 2
|
||
}],
|
||
140: [function(e, t) {
|
||
(function(n) {
|
||
"use strict";
|
||
|
||
function r(e, t, r) {
|
||
var o = e,
|
||
a = !o.hasOwnProperty(r);
|
||
"production" !== n.env.NODE_ENV && ("production" !== n.env.NODE_ENV ? i(a, "flattenChildren(...): 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), a && null != t && (o[r] = t)
|
||
}
|
||
|
||
function o(e) {
|
||
if (null == e) return e;
|
||
var t = {};
|
||
return a(e, r, t), t
|
||
}
|
||
var a = e("./traverseAllChildren"),
|
||
i = e("./warning");
|
||
t.exports = o
|
||
}).call(this, e("_process"))
|
||
}, {
|
||
"./traverseAllChildren": 176,
|
||
"./warning": 178,
|
||
_process: 2
|
||
}],
|
||
141: [function(e, t) {
|
||
"use strict";
|
||
|
||
function n(e) {
|
||
try {
|
||
e.focus()
|
||
} catch (t) {}
|
||
}
|
||
t.exports = n
|
||
}, {}],
|
||
142: [function(e, t) {
|
||
"use strict";
|
||
var n = function(e, t, n) {
|
||
Array.isArray(e) ? e.forEach(t, n) : e && t.call(n, e)
|
||
};
|
||
t.exports = n
|
||
}, {}],
|
||
143: [function(e, t) {
|
||
function n() {
|
||
try {
|
||
return document.activeElement || document.body
|
||
} catch (e) {
|
||
return document.body
|
||
}
|
||
}
|
||
t.exports = n
|
||
}, {}],
|
||
144: [function(e, t) {
|
||
"use strict";
|
||
|
||
function n(e) {
|
||
var t, n = e.keyCode;
|
||
return "charCode" in e ? (t = e.charCode, 0 === t && 13 === n && (t = 13)) : t = n, t >= 32 || 13 === t ? t : 0
|
||
}
|
||
t.exports = n
|
||
}, {}],
|
||
145: [function(e, t) {
|
||
"use strict";
|
||
|
||
function n(e) {
|
||
if (e.key) {
|
||
var t = o[e.key] || e.key;
|
||
if ("Unidentified" !== t) return t
|
||
}
|
||
if ("keypress" === e.type) {
|
||
var n = r(e);
|
||
return 13 === n ? "Enter" : String.fromCharCode(n)
|
||
}
|
||
return "keydown" === e.type || "keyup" === e.type ? a[e.keyCode] || "Unidentified" : ""
|
||
}
|
||
var r = e("./getEventCharCode"),
|
||
o = {
|
||
Esc: "Escape",
|
||
Spacebar: " ",
|
||
Left: "ArrowLeft",
|
||
Up: "ArrowUp",
|
||
Right: "ArrowRight",
|
||
Down: "ArrowDown",
|
||
Del: "Delete",
|
||
Win: "OS",
|
||
Menu: "ContextMenu",
|
||
Apps: "ContextMenu",
|
||
Scroll: "ScrollLock",
|
||
MozPrintableKey: "Unidentified"
|
||
},
|
||
a = {
|
||
8: "Backspace",
|
||
9: "Tab",
|
||
12: "Clear",
|
||
13: "Enter",
|
||
16: "Shift",
|
||
17: "Control",
|
||
18: "Alt",
|
||
19: "Pause",
|
||
20: "CapsLock",
|
||
27: "Escape",
|
||
32: " ",
|
||
33: "PageUp",
|
||
34: "PageDown",
|
||
35: "End",
|
||
36: "Home",
|
||
37: "ArrowLeft",
|
||
38: "ArrowUp",
|
||
39: "ArrowRight",
|
||
40: "ArrowDown",
|
||
45: "Insert",
|
||
46: "Delete",
|
||
112: "F1",
|
||
113: "F2",
|
||
114: "F3",
|
||
115: "F4",
|
||
116: "F5",
|
||
117: "F6",
|
||
118: "F7",
|
||
119: "F8",
|
||
120: "F9",
|
||
121: "F10",
|
||
122: "F11",
|
||
123: "F12",
|
||
144: "NumLock",
|
||
145: "ScrollLock",
|
||
224: "Meta"
|
||
};
|
||
t.exports = n
|
||
}, {
|
||
"./getEventCharCode": 144
|
||
}],
|
||
146: [function(e, t) {
|
||
"use strict";
|
||
|
||
function n(e) {
|
||
var t = this,
|
||
n = t.nativeEvent;
|
||
if (n.getModifierState) return n.getModifierState(e);
|
||
var r = o[e];
|
||
return r ? !!n[r] : !1
|
||
}
|
||
|
||
function r() {
|
||
return n
|
||
}
|
||
var o = {
|
||
Alt: "altKey",
|
||
Control: "ctrlKey",
|
||
Meta: "metaKey",
|
||
Shift: "shiftKey"
|
||
};
|
||
t.exports = r
|
||
}, {}],
|
||
147: [function(e, t) {
|
||
"use strict";
|
||
|
||
function n(e) {
|
||
var t = e.target || e.srcElement || window;
|
||
return 3 === t.nodeType ? t.parentNode : t
|
||
}
|
||
t.exports = n
|
||
}, {}],
|
||
148: [function(e, t) {
|
||
"use strict";
|
||
|
||
function n(e) {
|
||
var t = e && (r && e[r] || e[o]);
|
||
return "function" == typeof t ? t : void 0
|
||
}
|
||
var r = "function" == typeof Symbol && Symbol.iterator,
|
||
o = "@@iterator";
|
||
t.exports = n
|
||
}, {}],
|
||
149: [function(e, t) {
|
||
(function(n) {
|
||
function r(e) {
|
||
return "production" !== n.env.NODE_ENV ? a(!!i, "Markup wrapping node not initialized") : a(!!i), d.hasOwnProperty(e) || (e = "*"), s.hasOwnProperty(e) || (i.innerHTML = "*" === e ? "<link />" : "<" + e + "></" + e + ">", s[e] = !i.firstChild), s[e] ? d[e] : null
|
||
}
|
||
var o = e("./ExecutionEnvironment"),
|
||
a = e("./invariant"),
|
||
i = o.canUseDOM ? document.createElement("div") : null,
|
||
s = {
|
||
circle: !0,
|
||
defs: !0,
|
||
ellipse: !0,
|
||
g: !0,
|
||
line: !0,
|
||
linearGradient: !0,
|
||
path: !0,
|
||
polygon: !0,
|
||
polyline: !0,
|
||
radialGradient: !0,
|
||
rect: !0,
|
||
stop: !0,
|
||
text: !0
|
||
},
|
||
u = [1, '<select multiple="true">', "</select>"],
|
||
c = [1, "<table>", "</table>"],
|
||
l = [3, "<table><tbody><tr>", "</tr></tbody></table>"],
|
||
p = [1, "<svg>", "</svg>"],
|
||
d = {
|
||
"*": [1, "?<div>", "</div>"],
|
||
area: [1, "<map>", "</map>"],
|
||
col: [2, "<table><tbody></tbody><colgroup>", "</colgroup></table>"],
|
||
legend: [1, "<fieldset>", "</fieldset>"],
|
||
param: [1, "<object>", "</object>"],
|
||
tr: [2, "<table><tbody>", "</tbody></table>"],
|
||
optgroup: u,
|
||
option: u,
|
||
caption: c,
|
||
colgroup: c,
|
||
tbody: c,
|
||
tfoot: c,
|
||
thead: c,
|
||
td: l,
|
||
th: l,
|
||
circle: p,
|
||
defs: p,
|
||
ellipse: p,
|
||
g: p,
|
||
line: p,
|
||
linearGradient: p,
|
||
path: p,
|
||
polygon: p,
|
||
polyline: p,
|
||
radialGradient: p,
|
||
rect: p,
|
||
stop: p,
|
||
text: p
|
||
};
|
||
t.exports = r
|
||
}).call(this, e("_process"))
|
||
}, {
|
||
"./ExecutionEnvironment": 28,
|
||
"./invariant": 157,
|
||
_process: 2
|
||
}],
|
||
150: [function(e, t) {
|
||
"use strict";
|
||
|
||
function n(e) {
|
||
for (; e && e.firstChild;) e = e.firstChild;
|
||
return e
|
||
}
|
||
|
||
function r(e) {
|
||
for (; e;) {
|
||
if (e.nextSibling) return e.nextSibling;
|
||
e = e.parentNode
|
||
}
|
||
}
|
||
|
||
function o(e, t) {
|
||
for (var o = n(e), a = 0, i = 0; o;) {
|
||
if (3 === o.nodeType) {
|
||
if (i = a + o.textContent.length, t >= a && i >= t) return {
|
||
node: o,
|
||
offset: t - a
|
||
};
|
||
a = i
|
||
}
|
||
o = n(r(o))
|
||
}
|
||
}
|
||
t.exports = o
|
||
}, {}],
|
||
151: [function(e, t) {
|
||
"use strict";
|
||
|
||
function n(e) {
|
||
return e ? e.nodeType === r ? e.documentElement : e.firstChild : null
|
||
}
|
||
var r = 9;
|
||
t.exports = n
|
||
}, {}],
|
||
152: [function(e, t) {
|
||
"use strict";
|
||
|
||
function n() {
|
||
return !o && r.canUseDOM && (o = "textContent" in document.documentElement ? "textContent" : "innerText"), o
|
||
}
|
||
var r = e("./ExecutionEnvironment"),
|
||
o = null;
|
||
t.exports = n
|
||
}, {
|
||
"./ExecutionEnvironment": 28
|
||
}],
|
||
153: [function(e, t) {
|
||
"use strict";
|
||
|
||
function n(e) {
|
||
return e === window ? {
|
||
x: window.pageXOffset || document.documentElement.scrollLeft,
|
||
y: window.pageYOffset || document.documentElement.scrollTop
|
||
} : {
|
||
x: e.scrollLeft,
|
||
y: e.scrollTop
|
||
}
|
||
}
|
||
t.exports = n
|
||
}, {}],
|
||
154: [function(e, t) {
|
||
function n(e) {
|
||
return e.replace(r, "-$1").toLowerCase()
|
||
}
|
||
var r = /([A-Z])/g;
|
||
t.exports = n
|
||
}, {}],
|
||
155: [function(e, t) {
|
||
"use strict";
|
||
|
||
function n(e) {
|
||
return r(e).replace(o, "-ms-")
|
||
}
|
||
var r = e("./hyphenate"),
|
||
o = /^ms-/;
|
||
t.exports = n
|
||
}, {
|
||
"./hyphenate": 154
|
||
}],
|
||
156: [function(e, t) {
|
||
(function(n) {
|
||
"use strict";
|
||
|
||
function r(e) {
|
||
return "function" == typeof e && "function" == typeof e.prototype.mountComponent && "function" == typeof e.prototype.receiveComponent
|
||
}
|
||
|
||
function o(e, t) {
|
||
var o;
|
||
if ((null === e || e === !1) && (e = i.emptyElement), "object" == typeof e) {
|
||
var a = e;
|
||
"production" !== n.env.NODE_ENV && ("production" !== n.env.NODE_ENV ? l(a && ("function" == typeof a.type || "string" == typeof a.type), "Only functions or strings can be mounted as React components.") : null), o = t === a.type && "string" == typeof a.type ? s.createInternalComponent(a) : r(a.type) ? new a.type(a) : new p
|
||
} else "string" == typeof e || "number" == typeof e ? o = s.createInstanceForText(e) : "production" !== n.env.NODE_ENV ? c(!1, "Encountered invalid React node of type %s", typeof e) : c(!1);
|
||
return "production" !== n.env.NODE_ENV && ("production" !== n.env.NODE_ENV ? l("function" == typeof o.construct && "function" == typeof o.mountComponent && "function" == typeof o.receiveComponent && "function" == typeof o.unmountComponent, "Only React Components can be mounted.") : null), o.construct(e), o._mountIndex = 0, o._mountImage = null, "production" !== n.env.NODE_ENV && (o._isOwnerNecessary = !1, o._warnedAboutRefsInRender = !1), "production" !== n.env.NODE_ENV && Object.preventExtensions && Object.preventExtensions(o), o
|
||
}
|
||
var a = e("./ReactCompositeComponent"),
|
||
i = e("./ReactEmptyComponent"),
|
||
s = e("./ReactNativeComponent"),
|
||
u = e("./Object.assign"),
|
||
c = e("./invariant"),
|
||
l = e("./warning"),
|
||
p = function() {};
|
||
u(p.prototype, a.Mixin, {
|
||
_instantiateReactComponent: o
|
||
}), t.exports = o
|
||
}).call(this, e("_process"))
|
||
}, {
|
||
"./Object.assign": 35,
|
||
"./ReactCompositeComponent": 49,
|
||
"./ReactEmptyComponent": 71,
|
||
"./ReactNativeComponent": 86,
|
||
"./invariant": 157,
|
||
"./warning": 178,
|
||
_process: 2
|
||
}],
|
||
157: [function(e, t) {
|
||
(function(e) {
|
||
"use strict";
|
||
var n = function(t, n, r, o, a, i, s, u) {
|
||
if ("production" !== e.env.NODE_ENV && void 0 === n) throw new Error("invariant requires an error message argument");
|
||
if (!t) {
|
||
var c;
|
||
if (void 0 === n) c = new Error("Minified exception occurred; use the non-minified dev environment for the full error message and additional helpful warnings.");
|
||
else {
|
||
var l = [r, o, a, i, s, u],
|
||
p = 0;
|
||
c = new Error("Invariant Violation: " + n.replace(/%s/g, function() {
|
||
return l[p++]
|
||
}))
|
||
}
|
||
throw c.framesToPop = 1, c
|
||
}
|
||
};
|
||
t.exports = n
|
||
}).call(this, e("_process"))
|
||
}, {
|
||
_process: 2
|
||
}],
|
||
158: [function(e, t) {
|
||
"use strict";
|
||
|
||
function n(e, t) {
|
||
if (!o.canUseDOM || t && !("addEventListener" in document)) return !1;
|
||
var n = "on" + e,
|
||
a = n in document;
|
||
if (!a) {
|
||
var i = document.createElement("div");
|
||
i.setAttribute(n, "return;"), a = "function" == typeof i[n]
|
||
}
|
||
return !a && r && "wheel" === e && (a = document.implementation.hasFeature("Events.wheel", "3.0")), a
|
||
}
|
||
var r, o = e("./ExecutionEnvironment");
|
||
o.canUseDOM && (r = document.implementation && document.implementation.hasFeature && document.implementation.hasFeature("", "") !== !0), t.exports = n
|
||
}, {
|
||
"./ExecutionEnvironment": 28
|
||
}],
|
||
159: [function(e, t) {
|
||
function n(e) {
|
||
return !(!e || !("function" == typeof Node ? e instanceof Node : "object" == typeof e && "number" == typeof e.nodeType && "string" == typeof e.nodeName))
|
||
}
|
||
t.exports = n
|
||
}, {}],
|
||
160: [function(e, t) {
|
||
"use strict";
|
||
|
||
function n(e) {
|
||
return e && ("INPUT" === e.nodeName && r[e.type] || "TEXTAREA" === e.nodeName)
|
||
}
|
||
var r = {
|
||
color: !0,
|
||
date: !0,
|
||
datetime: !0,
|
||
"datetime-local": !0,
|
||
email: !0,
|
||
month: !0,
|
||
number: !0,
|
||
password: !0,
|
||
range: !0,
|
||
search: !0,
|
||
tel: !0,
|
||
text: !0,
|
||
time: !0,
|
||
url: !0,
|
||
week: !0
|
||
};
|
||
t.exports = n
|
||
}, {}],
|
||
161: [function(e, t) {
|
||
function n(e) {
|
||
return r(e) && 3 == e.nodeType
|
||
}
|
||
var r = e("./isNode");
|
||
t.exports = n
|
||
}, {
|
||
"./isNode": 159
|
||
}],
|
||
162: [function(e, t) {
|
||
"use strict";
|
||
|
||
function n(e) {
|
||
e || (e = "");
|
||
var t, n = arguments.length;
|
||
if (n > 1)
|
||
for (var r = 1; n > r; r++) t = arguments[r], t && (e = (e ? e + " " : "") + t);
|
||
return e
|
||
}
|
||
t.exports = n
|
||
}, {}],
|
||
163: [function(e, t) {
|
||
(function(n) {
|
||
"use strict";
|
||
var r = e("./invariant"),
|
||
o = function(e) {
|
||
var t, o = {};
|
||
"production" !== n.env.NODE_ENV ? r(e instanceof Object && !Array.isArray(e), "keyMirror(...): Argument must be an object.") : r(e instanceof Object && !Array.isArray(e));
|
||
for (t in e) e.hasOwnProperty(t) && (o[t] = t);
|
||
return o
|
||
};
|
||
t.exports = o
|
||
}).call(this, e("_process"))
|
||
}, {
|
||
"./invariant": 157,
|
||
_process: 2
|
||
}],
|
||
164: [function(e, t) {
|
||
var n = function(e) {
|
||
var t;
|
||
for (t in e)
|
||
if (e.hasOwnProperty(t)) return t;
|
||
return null
|
||
};
|
||
t.exports = n
|
||
}, {}],
|
||
165: [function(e, t) {
|
||
"use strict";
|
||
|
||
function n(e, t, n) {
|
||
if (!e) return null;
|
||
var o = {};
|
||
for (var a in e) r.call(e, a) && (o[a] = t.call(n, e[a], a, e));
|
||
return o
|
||
}
|
||
var r = Object.prototype.hasOwnProperty;
|
||
t.exports = n
|
||
}, {}],
|
||
166: [function(e, t) {
|
||
"use strict";
|
||
|
||
function n(e) {
|
||
var t = {};
|
||
return function(n) {
|
||
return t.hasOwnProperty(n) || (t[n] = e.call(this, n)), t[n]
|
||
}
|
||
}
|
||
t.exports = n
|
||
}, {}],
|
||
167: [function(e, t) {
|
||
(function(n) {
|
||
"use strict";
|
||
|
||
function r(e) {
|
||
return "production" !== n.env.NODE_ENV ? a(o.isValidElement(e), "onlyChild must be passed a children with exactly one child.") : a(o.isValidElement(e)), e
|
||
}
|
||
var o = e("./ReactElement"),
|
||
a = e("./invariant");
|
||
t.exports = r
|
||
}).call(this, e("_process"))
|
||
}, {
|
||
"./ReactElement": 69,
|
||
"./invariant": 157,
|
||
_process: 2
|
||
}],
|
||
168: [function(e, t) {
|
||
"use strict";
|
||
var n, r = e("./ExecutionEnvironment");
|
||
r.canUseDOM && (n = window.performance || window.msPerformance || window.webkitPerformance), t.exports = n || {}
|
||
}, {
|
||
"./ExecutionEnvironment": 28
|
||
}],
|
||
169: [function(e, t) {
|
||
var n = e("./performance");
|
||
n && n.now || (n = Date);
|
||
var r = n.now.bind(n);
|
||
t.exports = r
|
||
}, {
|
||
"./performance": 168
|
||
}],
|
||
170: [function(e, t) {
|
||
"use strict";
|
||
|
||
function n(e) {
|
||
return '"' + r(e) + '"'
|
||
}
|
||
var r = e("./escapeTextContentForBrowser");
|
||
t.exports = n
|
||
}, {
|
||
"./escapeTextContentForBrowser": 138
|
||
}],
|
||
171: [function(e, t) {
|
||
"use strict";
|
||
var n = e("./ExecutionEnvironment"),
|
||
r = /^[ \r\n\t\f]/,
|
||
o = /<(!--|link|noscript|meta|script|style)[ \r\n\t\f\/>]/,
|
||
a = function(e, t) {
|
||
e.innerHTML = t
|
||
};
|
||
if ("undefined" != typeof MSApp && MSApp.execUnsafeLocalFunction && (a = function(e, t) {
|
||
MSApp.execUnsafeLocalFunction(function() {
|
||
e.innerHTML = t
|
||
})
|
||
}), n.canUseDOM) {
|
||
var i = document.createElement("div");
|
||
i.innerHTML = " ", "" === i.innerHTML && (a = function(e, t) {
|
||
if (e.parentNode && e.parentNode.replaceChild(e, e), r.test(t) || "<" === t[0] && o.test(t)) {
|
||
e.innerHTML = "\ufeff" + t;
|
||
var n = e.firstChild;
|
||
1 === n.data.length ? e.removeChild(n) : n.deleteData(0, 1)
|
||
} else e.innerHTML = t
|
||
})
|
||
}
|
||
t.exports = a
|
||
}, {
|
||
"./ExecutionEnvironment": 28
|
||
}],
|
||
172: [function(e, t) {
|
||
"use strict";
|
||
var n = e("./ExecutionEnvironment"),
|
||
r = e("./escapeTextContentForBrowser"),
|
||
o = e("./setInnerHTML"),
|
||
a = function(e, t) {
|
||
e.textContent = t
|
||
};
|
||
n.canUseDOM && ("textContent" in document.documentElement || (a = function(e, t) {
|
||
o(e, r(t))
|
||
})), t.exports = a
|
||
}, {
|
||
"./ExecutionEnvironment": 28,
|
||
"./escapeTextContentForBrowser": 138,
|
||
"./setInnerHTML": 171
|
||
}],
|
||
173: [function(e, t) {
|
||
"use strict";
|
||
|
||
function n(e, t) {
|
||
if (e === t) return !0;
|
||
var n;
|
||
for (n in e)
|
||
if (e.hasOwnProperty(n) && (!t.hasOwnProperty(n) || e[n] !== t[n])) return !1;
|
||
for (n in t)
|
||
if (t.hasOwnProperty(n) && !e.hasOwnProperty(n)) return !1;
|
||
return !0
|
||
}
|
||
t.exports = n
|
||
}, {}],
|
||
174: [function(e, t) {
|
||
(function(n) {
|
||
"use strict";
|
||
|
||
function r(e, t) {
|
||
if (null != e && null != t) {
|
||
var r = typeof e,
|
||
a = typeof t;
|
||
if ("string" === r || "number" === r) return "string" === a || "number" === a;
|
||
if ("object" === a && e.type === t.type && e.key === t.key) {
|
||
var i = e._owner === t._owner,
|
||
s = null,
|
||
u = null,
|
||
c = null;
|
||
return "production" !== n.env.NODE_ENV && (i || (null != e._owner && null != e._owner.getPublicInstance() && null != e._owner.getPublicInstance().constructor && (s = e._owner.getPublicInstance().constructor.displayName), null != t._owner && null != t._owner.getPublicInstance() && null != t._owner.getPublicInstance().constructor && (u = t._owner.getPublicInstance().constructor.displayName), null != t.type && null != t.type.displayName && (c = t.type.displayName), null != t.type && "string" == typeof t.type && (c = t.type), ("string" != typeof t.type || "input" === t.type || "textarea" === t.type) && (null != e._owner && e._owner._isOwnerNecessary === !1 || null != t._owner && t._owner._isOwnerNecessary === !1) && (null != e._owner && (e._owner._isOwnerNecessary = !0), null != t._owner && (t._owner._isOwnerNecessary = !0), "production" !== n.env.NODE_ENV ? o(!1, "<%s /> is being rendered by both %s and %s using the same key (%s) in the same place. Currently, this means that they don't preserve state. This behavior should be very rare so we're considering deprecating it. Please contact the React team and explain your use case so that we can take that into consideration.", c || "Unknown Component", s || "[Unknown]", u || "[Unknown]", e.key) : null))), i
|
||
}
|
||
}
|
||
return !1
|
||
}
|
||
var o = e("./warning");
|
||
t.exports = r
|
||
}).call(this, e("_process"))
|
||
}, {
|
||
"./warning": 178,
|
||
_process: 2
|
||
}],
|
||
175: [function(e, t) {
|
||
(function(n) {
|
||
function r(e) {
|
||
var t = e.length;
|
||
if ("production" !== n.env.NODE_ENV ? o(!Array.isArray(e) && ("object" == typeof e || "function" == typeof e), "toArray: Array-like object expected") : o(!Array.isArray(e) && ("object" == typeof e || "function" == typeof e)), "production" !== n.env.NODE_ENV ? o("number" == typeof t, "toArray: Object needs a length property") : o("number" == typeof t), "production" !== n.env.NODE_ENV ? o(0 === t || t - 1 in e, "toArray: Object should have keys for indices") : o(0 === t || t - 1 in e), e.hasOwnProperty) try {
|
||
return Array.prototype.slice.call(e)
|
||
} catch (r) {}
|
||
for (var a = Array(t), i = 0; t > i; i++) a[i] = e[i];
|
||
return a
|
||
}
|
||
var o = e("./invariant");
|
||
t.exports = r
|
||
}).call(this, e("_process"))
|
||
}, {
|
||
"./invariant": 157,
|
||
_process: 2
|
||
}],
|
||
176: [function(e, t) {
|
||
(function(n) {
|
||
"use strict";
|
||
|
||
function r(e) {
|
||
return y[e]
|
||
}
|
||
|
||
function o(e, t) {
|
||
return e && null != e.key ? i(e.key) : t.toString(36)
|
||
}
|
||
|
||
function a(e) {
|
||
return ("" + e).replace(g, r)
|
||
}
|
||
|
||
function i(e) {
|
||
return "$" + a(e)
|
||
}
|
||
|
||
function s(e, t, r, a, u) {
|
||
var p = typeof e;
|
||
if (("undefined" === p || "boolean" === p) && (e = null), null === e || "string" === p || "number" === p || c.isValidElement(e)) return a(u, e, "" === t ? v + o(e, 0) : t, r), 1;
|
||
var y, g, C, b = 0;
|
||
if (Array.isArray(e))
|
||
for (var _ = 0; _ < e.length; _++) y = e[_], g = ("" !== t ? t + m : v) + o(y, _), C = r + b, b += s(y, g, C, a, u);
|
||
else {
|
||
var N = d(e);
|
||
if (N) {
|
||
var O, R = N.call(e);
|
||
if (N !== e.entries)
|
||
for (var D = 0; !(O = R.next()).done;) y = O.value, g = ("" !== t ? t + m : v) + o(y, D++), C = r + b, b += s(y, g, C, a, u);
|
||
else
|
||
for ("production" !== n.env.NODE_ENV && ("production" !== n.env.NODE_ENV ? h(E, "Using Maps as children is not yet fully supported. It is an experimental feature that might be removed. Convert it to a sequence / iterable of keyed ReactElements instead.") : null, E = !0); !(O = R.next()).done;) {
|
||
var w = O.value;
|
||
w && (y = w[1], g = ("" !== t ? t + m : v) + i(w[0]) + m + o(y, 0), C = r + b, b += s(y, g, C, a, u))
|
||
}
|
||
} else if ("object" === p) {
|
||
"production" !== n.env.NODE_ENV ? f(1 !== e.nodeType, "traverseAllChildren(...): Encountered an invalid child; DOM elements are not valid children of React components.") : f(1 !== e.nodeType);
|
||
var M = l.extract(e);
|
||
for (var x in M) M.hasOwnProperty(x) && (y = M[x], g = ("" !== t ? t + m : v) + i(x) + m + o(y, 0), C = r + b, b += s(y, g, C, a, u))
|
||
}
|
||
}
|
||
return b
|
||
}
|
||
|
||
function u(e, t, n) {
|
||
return null == e ? 0 : s(e, "", 0, t, n)
|
||
}
|
||
var c = e("./ReactElement"),
|
||
l = e("./ReactFragment"),
|
||
p = e("./ReactInstanceHandles"),
|
||
d = e("./getIteratorFn"),
|
||
f = e("./invariant"),
|
||
h = e("./warning"),
|
||
v = p.SEPARATOR,
|
||
m = ":",
|
||
y = {
|
||
"=": "=0",
|
||
".": "=1",
|
||
":": "=2"
|
||
},
|
||
g = /[=.:]/g,
|
||
E = !1;
|
||
t.exports = u
|
||
}).call(this, e("_process"))
|
||
}, {
|
||
"./ReactElement": 69,
|
||
"./ReactFragment": 75,
|
||
"./ReactInstanceHandles": 78,
|
||
"./getIteratorFn": 148,
|
||
"./invariant": 157,
|
||
"./warning": 178,
|
||
_process: 2
|
||
}],
|
||
177: [function(e, t) {
|
||
(function(n) {
|
||
"use strict";
|
||
|
||
function r(e) {
|
||
return Array.isArray(e) ? e.concat() : e && "object" == typeof e ? i(new e.constructor, e) : e
|
||
}
|
||
|
||
function o(e, t, r) {
|
||
"production" !== n.env.NODE_ENV ? u(Array.isArray(e), "update(): expected target of %s to be an array; got %s.", r, e) : u(Array.isArray(e));
|
||
var o = t[r];
|
||
"production" !== n.env.NODE_ENV ? u(Array.isArray(o), "update(): expected spec of %s to be an array; got %s. Did you forget to wrap your parameter in an array?", r, o) : u(Array.isArray(o))
|
||
}
|
||
|
||
function a(e, t) {
|
||
if ("production" !== n.env.NODE_ENV ? u("object" == typeof t, "update(): You provided a key path to update() that did not contain one of %s. Did you forget to include {%s: ...}?", v.join(", "), d) : u("object" == typeof t), t.hasOwnProperty(d)) return "production" !== n.env.NODE_ENV ? u(1 === Object.keys(t).length, "Cannot have more than one key in an object with %s", d) : u(1 === Object.keys(t).length), t[d];
|
||
var s = r(e);
|
||
if (t.hasOwnProperty(f)) {
|
||
var y = t[f];
|
||
"production" !== n.env.NODE_ENV ? u(y && "object" == typeof y, "update(): %s expects a spec of type 'object'; got %s", f, y) : u(y && "object" == typeof y), "production" !== n.env.NODE_ENV ? u(s && "object" == typeof s, "update(): %s expects a target of type 'object'; got %s", f, s) : u(s && "object" == typeof s), i(s, t[f])
|
||
}
|
||
t.hasOwnProperty(c) && (o(e, t, c), t[c].forEach(function(e) {
|
||
s.push(e)
|
||
})), t.hasOwnProperty(l) && (o(e, t, l), t[l].forEach(function(e) {
|
||
s.unshift(e)
|
||
})), t.hasOwnProperty(p) && ("production" !== n.env.NODE_ENV ? u(Array.isArray(e), "Expected %s target to be an array; got %s", p, e) : u(Array.isArray(e)), "production" !== n.env.NODE_ENV ? u(Array.isArray(t[p]), "update(): expected spec of %s to be an array of arrays; got %s. Did you forget to wrap your parameters in an array?", p, t[p]) : u(Array.isArray(t[p])), t[p].forEach(function(e) {
|
||
"production" !== n.env.NODE_ENV ? u(Array.isArray(e), "update(): expected spec of %s to be an array of arrays; got %s. Did you forget to wrap your parameters in an array?", p, t[p]) : u(Array.isArray(e)), s.splice.apply(s, e)
|
||
})), t.hasOwnProperty(h) && ("production" !== n.env.NODE_ENV ? u("function" == typeof t[h], "update(): expected spec of %s to be a function; got %s.", h, t[h]) : u("function" == typeof t[h]), s = t[h](s));
|
||
for (var g in t) m.hasOwnProperty(g) && m[g] || (s[g] = a(e[g], t[g]));
|
||
return s
|
||
}
|
||
var i = e("./Object.assign"),
|
||
s = e("./keyOf"),
|
||
u = e("./invariant"),
|
||
c = s({
|
||
$push: null
|
||
}),
|
||
l = s({
|
||
$unshift: null
|
||
}),
|
||
p = s({
|
||
$splice: null
|
||
}),
|
||
d = s({
|
||
$set: null
|
||
}),
|
||
f = s({
|
||
$merge: null
|
||
}),
|
||
h = s({
|
||
$apply: null
|
||
}),
|
||
v = [c, l, p, d, f, h],
|
||
m = {};
|
||
v.forEach(function(e) {
|
||
m[e] = !0
|
||
}), t.exports = a
|
||
}).call(this, e("_process"))
|
||
}, {
|
||
"./Object.assign": 35,
|
||
"./invariant": 157,
|
||
"./keyOf": 164,
|
||
_process: 2
|
||
}],
|
||
178: [function(e, t) {
|
||
(function(n) {
|
||
"use strict";
|
||
var r = e("./emptyFunction"),
|
||
o = r;
|
||
"production" !== n.env.NODE_ENV && (o = function(e, t) {
|
||
for (var n = [], r = 2, o = arguments.length; o > r; r++) n.push(arguments[r]);
|
||
if (void 0 === t) throw new Error("`warning(condition, format, ...args)` requires a warning message argument");
|
||
if (t.length < 10 || /^[s\W]*$/.test(t)) throw new Error("The warning format should be able to uniquely identify this warning. Please, use a more descriptive format than: " + t);
|
||
if (0 !== t.indexOf("Failed Composite propType: ") && !e) {
|
||
var a = 0,
|
||
i = "Warning: " + t.replace(/%s/g, function() {
|
||
return n[a++]
|
||
});
|
||
console.warn(i);
|
||
try {
|
||
throw new Error(i)
|
||
} catch (s) {}
|
||
}
|
||
}), t.exports = o
|
||
}).call(this, e("_process"))
|
||
}, {
|
||
"./emptyFunction": 136,
|
||
_process: 2
|
||
}],
|
||
179: [function(e, t) {
|
||
t.exports = e("./lib/React")
|
||
}, {
|
||
"./lib/React": 37
|
||
}],
|
||
180: [function(e, t) {
|
||
(function(n) {
|
||
"use strict";
|
||
|
||
function r(e, t) {
|
||
return function(n, r, o, i) {
|
||
return void 0 !== n[r] ? n[e] ? t && t(n, r, o, i) : new Error("You have provided a `" + r + "` prop to `" + o + "` without an `" + e + "` handler. This will render a read-only field. If the field should be mutable use `" + a(r) + "`. Otherwise, set `" + e + "`") : void 0
|
||
}
|
||
}
|
||
|
||
function o(e) {
|
||
return 0 === f[0] && f[1] >= 13 ? e : e.type
|
||
}
|
||
|
||
function a(e) {
|
||
return "default" + e.charAt(0).toUpperCase() + e.substr(1)
|
||
}
|
||
|
||
function i(e, t, n) {
|
||
return function() {
|
||
for (var r = arguments.length, o = Array(r), a = 0; r > a; a++) o[a] = arguments[a];
|
||
t && t.call.apply(t, [e].concat(o)), n && n.call.apply(n, [e].concat(o))
|
||
}
|
||
}
|
||
|
||
function s(e, t, n) {
|
||
return u(e, t.bind(null, n = n || (Array.isArray(e) ? [] : {}))), n
|
||
}
|
||
|
||
function u(e, t, n) {
|
||
if (Array.isArray(e)) return e.forEach(t, n);
|
||
for (var r in e) c(e, r) && t.call(n, e[r], r, e)
|
||
}
|
||
|
||
function c(e, t) {
|
||
return e ? Object.prototype.hasOwnProperty.call(e, t) : !1
|
||
}
|
||
var l = e("./util/babelHelpers.js"),
|
||
p = e("react"),
|
||
d = e("react/lib/invariant"),
|
||
f = p.version.split(".").map(parseFloat);
|
||
t.exports = function(e, t, c) {
|
||
function f(e, n) {
|
||
for (var r = arguments.length, o = Array(r > 2 ? r - 2 : 0), a = 2; r > a; a++) o[a - 2] = arguments[a];
|
||
var o, i = t[e],
|
||
s = i && h(this.props, e);
|
||
if (this.props[i]) {
|
||
var u;
|
||
this._notifying = !0, (u = this.props[i]).call.apply(u, [this, n].concat(o)), this._notifying = !1
|
||
}
|
||
return this.setState(function() {
|
||
var t = {};
|
||
return t[e] = n, t
|
||
}()), !s
|
||
}
|
||
|
||
function h(e, t) {
|
||
return void 0 !== e[t]
|
||
}
|
||
var v = {};
|
||
return "production" !== n.env.NODE_ENV && o(e).propTypes && (v = s(t, function(t, n, i) {
|
||
var s = o(e).propTypes[i];
|
||
d("string" == typeof n && n.trim().length, "Uncontrollable - [%s]: the prop `%s` needs a valid handler key name in order to make it uncontrollable", e.displayName, i), t[i] = r(n, s), void 0 !== s && (t[a(i)] = s)
|
||
}, {})), c = c || {}, p.createClass({
|
||
displayName: e.displayName,
|
||
propTypes: v,
|
||
getInitialState: function() {
|
||
var e = this.props,
|
||
n = Object.keys(t);
|
||
return s(n, function(t, n) {
|
||
t[n] = e[a(n)]
|
||
}, {})
|
||
},
|
||
shouldComponentUpdate: function() {
|
||
return !this._notifying
|
||
},
|
||
render: function() {
|
||
var n = this,
|
||
r = {};
|
||
return u(t, function(e, t) {
|
||
r[t] = h(n.props, t) ? n.props[t] : n.state[t], r[e] = f.bind(n, t)
|
||
}), r = l._extends({}, this.props, r), u(c, function(e, t) {
|
||
return r[t] = i(n, e, r[t])
|
||
}), p.createElement(e, r)
|
||
}
|
||
})
|
||
}
|
||
}).call(this, e("_process"))
|
||
}, {
|
||
"./util/babelHelpers.js": 181,
|
||
_process: 2,
|
||
react: 179,
|
||
"react/lib/invariant": 157
|
||
}],
|
||
181: [function(e, t, n) {
|
||
! function(e, t) {
|
||
"function" == typeof define && define.amd ? define(["exports"], t) : t("object" == typeof n ? n : e.babelHelpers = {})
|
||
}(this, function(e) {
|
||
var t = e;
|
||
t._extends = Object.assign || function(e) {
|
||
for (var t = 1; t < arguments.length; t++) {
|
||
var n = arguments[t];
|
||
for (var r in n) Object.prototype.hasOwnProperty.call(n, r) && (e[r] = n[r])
|
||
}
|
||
return e
|
||
}
|
||
})
|
||
}, {}],
|
||
182: [function(e, t) {
|
||
t.exports = {
|
||
name: "Bezier-easing-editor for DS4Windows (curve output of analog gamepad axis)",
|
||
version: "0.3.3",
|
||
description: "Cubic Bezier Curve editor made with React & SVG",
|
||
main: "src/index.js",
|
||
peerDependencies: {
|
||
react: ">=0.12.0 <0.14.0"
|
||
},
|
||
browserify: {
|
||
transform: ["babelify"]
|
||
},
|
||
repository: {
|
||
type: "git",
|
||
url: "git@github.com:gre/bezier-easing-editor.git"
|
||
},
|
||
keywords: ["react-component", "bezier-easing", "cubic-bezier", "easing", "editor"],
|
||
author: "Author of the original beizer-curve-editor, Ga<47>tan Renaudeau",
|
||
license: "ISC",
|
||
bugs: {
|
||
url: "https://github.com/gre/bezier-easing-editor/issues"
|
||
},
|
||
homepage: "https://github.com/gre/bezier-easing-editor",
|
||
devDependencies: {
|
||
babelify: "^5.0.4"
|
||
},
|
||
dependencies: {
|
||
"bezier-easing": "^0.4.4",
|
||
"object-assign": "^2.0.0",
|
||
uncontrollable: "^1.1.3"
|
||
}
|
||
}
|
||
}, {}],
|
||
183: [function(e, t) {
|
||
"use strict";
|
||
|
||
function n(e, t, n) {
|
||
return e * (1 - n) + t * n
|
||
}
|
||
var r = function(e) {
|
||
return e && e.__esModule ? e["default"] : e
|
||
},
|
||
o = 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
|
||
}
|
||
}(),
|
||
a = function l(e, t, n) {
|
||
var r = Object.getOwnPropertyDescriptor(e, t);
|
||
if (void 0 === r) {
|
||
var o = Object.getPrototypeOf(e);
|
||
return null === o ? void 0 : l(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)
|
||
},
|
||
i = 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)
|
||
},
|
||
s = function(e, t) {
|
||
if (!(e instanceof t)) throw new TypeError("Cannot call a class as a function")
|
||
},
|
||
u = r(e("react")),
|
||
c = function(e) {
|
||
function t(e) {
|
||
s(this, t), a(Object.getPrototypeOf(t.prototype), "constructor", this).call(this, e), this.x = this.x.bind(this), this.y = this.y.bind(this)
|
||
}
|
||
return i(t, e), o(t, {
|
||
shouldComponentUpdate: {
|
||
value: function(e) {
|
||
var t = this.props,
|
||
n = t.xFrom,
|
||
r = t.yFrom,
|
||
o = t.xTo,
|
||
a = t.yTo;
|
||
return e.xFrom !== n || e.yFrom !== r || e.xTo !== o || e.yTo !== a
|
||
}
|
||
},
|
||
x: {
|
||
value: function(e) {
|
||
return Math.round(n(this.props.xFrom, this.props.xTo, e))
|
||
}
|
||
},
|
||
y: {
|
||
value: function(e) {
|
||
return Math.round(n(this.props.yFrom, this.props.yTo, e))
|
||
}
|
||
}
|
||
}), t
|
||
}(u.Component);
|
||
t.exports = c
|
||
}, {
|
||
react: 179
|
||
}],
|
||
184: [function(e, t) {
|
||
"use strict";
|
||
var n = function(e) {
|
||
return e && e.__esModule ? e["default"] : e
|
||
},
|
||
r = function(e, t) {
|
||
if (Array.isArray(e)) return e;
|
||
if (Symbol.iterator in Object(e)) {
|
||
for (var n, r = [], o = e[Symbol.iterator](); !(n = o.next()).done && (r.push(n.value), !t || r.length !== t););
|
||
return r
|
||
}
|
||
throw new TypeError("Invalid attempt to destructure non-iterable instance")
|
||
},
|
||
o = 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
|
||
}
|
||
}(),
|
||
a = function C(e, t, n) {
|
||
var r = Object.getOwnPropertyDescriptor(e, t);
|
||
if (void 0 === r) {
|
||
var o = Object.getPrototypeOf(e);
|
||
return null === o ? void 0 : C(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)
|
||
},
|
||
i = 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)
|
||
},
|
||
s = function(e, t) {
|
||
if (!(e instanceof t)) throw new TypeError("Cannot call a class as a function")
|
||
},
|
||
u = Object.assign || function(e) {
|
||
for (var t = 1; t < arguments.length; t++) {
|
||
var n = arguments[t];
|
||
for (var r in n) Object.prototype.hasOwnProperty.call(n, r) && (e[r] = n[r])
|
||
}
|
||
return e
|
||
},
|
||
c = n(e("react")),
|
||
l = n(e("object-assign")),
|
||
p = c.PropTypes,
|
||
d = c.Component,
|
||
f = n(e("./Grid")),
|
||
h = n(e("./Handle")),
|
||
v = n(e("./Progress")),
|
||
m = n(e("./Curve")),
|
||
y = {
|
||
value: p.array,
|
||
onChange: p.func,
|
||
width: p.number,
|
||
height: p.number,
|
||
padding: p.array,
|
||
handleRadius: p.number,
|
||
style: p.object,
|
||
progress: p.number,
|
||
handleStroke: p.number,
|
||
background: p.string,
|
||
gridColor: p.string,
|
||
curveColor: p.string,
|
||
curveWidth: p.number,
|
||
handleColor: p.string,
|
||
color: p.string,
|
||
textStyle: p.object,
|
||
progressColor: p.string,
|
||
readOnly: p.bool
|
||
},
|
||
g = {
|
||
value: [.25, .25, .75, .75],
|
||
width: 300,
|
||
height: 300,
|
||
padding: [25, 5, 25, 18],
|
||
progress: 0,
|
||
background: "#fff",
|
||
color: "#000",
|
||
gridColor: "#eee",
|
||
curveColor: "#333",
|
||
progressColor: "#300",
|
||
handleColor: "#f00",
|
||
curveWidth: 2,
|
||
handleRadius: 5,
|
||
handleStroke: 2,
|
||
textStyle: {
|
||
fontFamily: "sans-serif",
|
||
fontSize: "10px"
|
||
},
|
||
pointers: {
|
||
down: "none",
|
||
hover: "pointer",
|
||
def: "default"
|
||
}
|
||
},
|
||
E = function(e) {
|
||
function t(e) {
|
||
s(this, t), a(Object.getPrototypeOf(t.prototype), "constructor", this).call(this, e), this.state = {
|
||
down: 0,
|
||
hover: 0
|
||
}, this.x = this.x.bind(this), this.y = this.y.bind(this), this.onDownLeave = this.onDownLeave.bind(this), this.onDownMove = this.onDownMove.bind(this), this.onDownUp = this.onDownUp.bind(this), this.onEnterHandle1 = this.onEnterHandle.bind(this, 1), this.onEnterHandle2 = this.onEnterHandle.bind(this, 2), this.onLeaveHandle1 = this.onLeaveHandle.bind(this, 1), this.onLeaveHandle2 = this.onLeaveHandle.bind(this, 2), this.onDownHandle1 = this.onDownHandle.bind(this, 1), this.onDownHandle2 = this.onDownHandle.bind(this, 2)
|
||
}
|
||
return i(t, e), o(t, {
|
||
render: {
|
||
value: function() {
|
||
var e = this,
|
||
t = e.x,
|
||
n = e.y,
|
||
r = this.props,
|
||
o = r.value,
|
||
a = r.width,
|
||
i = r.height,
|
||
s = r.handleRadius,
|
||
p = r.style,
|
||
d = r.progress,
|
||
E = r.handleStroke,
|
||
C = r.background,
|
||
b = r.gridColor,
|
||
_ = r.curveColor,
|
||
N = r.curveWidth,
|
||
O = r.handleColor,
|
||
R = r.textStyle,
|
||
D = r.progressColor,
|
||
w = r.readOnly,
|
||
M = r.pointers,
|
||
x = this.state,
|
||
T = x.down,
|
||
P = x.hover,
|
||
I = {
|
||
xFrom: t(0),
|
||
yFrom: n(0),
|
||
xTo: t(1),
|
||
yTo: n(1)
|
||
},
|
||
S = l({}, y.pointers, M),
|
||
k = l({
|
||
background: C,
|
||
cursor: T ? S.down : P ? S.hover : S.def,
|
||
userSelect: "none",
|
||
WebkitUserSelect: "none",
|
||
MozUserSelect: "none"
|
||
}, p),
|
||
A = w || !T ? {} : {
|
||
onMouseMove: this.onDownMove,
|
||
onMouseUp: this.onDownUp,
|
||
onMouseLeave: this.onDownLeave
|
||
},
|
||
V = w || T ? {} : {
|
||
onMouseDown: this.onDownHandle1,
|
||
onMouseEnter: this.onEnterHandle1,
|
||
onMouseLeave: this.onLeaveHandle1
|
||
},
|
||
U = w || T ? {} : {
|
||
onMouseDown: this.onDownHandle2,
|
||
onMouseEnter: this.onEnterHandle2,
|
||
onMouseLeave: this.onLeaveHandle2
|
||
};
|
||
return c.createElement("svg", u({
|
||
style: k,
|
||
width: a,
|
||
height: i
|
||
}, A), c.createElement(f, u({}, I, {
|
||
background: C,
|
||
gridColor: b,
|
||
textStyle: l({}, g.textStyle, R)
|
||
})), c.createElement(v, u({}, I, {
|
||
value: o,
|
||
progress: d,
|
||
progressColor: D
|
||
})), c.createElement(m, u({}, I, {
|
||
value: o,
|
||
curveColor: _,
|
||
curveWidth: N
|
||
})), this.props.children, w ? void 0 : c.createElement("g", null, c.createElement(h, u({}, I, V, {
|
||
index: 0,
|
||
xval: o[0],
|
||
yval: o[1],
|
||
handleRadius: s,
|
||
handleColor: O,
|
||
down: 1 === T,
|
||
hover: 1 === P,
|
||
handleStroke: E,
|
||
background: C
|
||
})), c.createElement(h, u({}, I, U, {
|
||
index: 1,
|
||
xval: o[2],
|
||
yval: o[3],
|
||
handleRadius: s,
|
||
handleColor: O,
|
||
down: 2 === T,
|
||
hover: 2 === P,
|
||
handleStroke: E,
|
||
background: C
|
||
}))))
|
||
}
|
||
},
|
||
onDownLeave: {
|
||
value: function(e) {
|
||
this.state.down && (this.onDownMove(e), this.setState({
|
||
down: null
|
||
}))
|
||
}
|
||
},
|
||
onDownHandle: {
|
||
value: function(e, t) {
|
||
t.preventDefault(), this.setState({
|
||
hover: null,
|
||
down: e
|
||
})
|
||
}
|
||
},
|
||
onEnterHandle: {
|
||
value: function(e) {
|
||
this.state.down || this.setState({
|
||
hover: e
|
||
})
|
||
}
|
||
},
|
||
onLeaveHandle: {
|
||
value: function() {
|
||
this.state.down || this.setState({
|
||
hover: null
|
||
})
|
||
}
|
||
},
|
||
onDownMove: {
|
||
value: function(e) {
|
||
if (this.state.down) {
|
||
e.preventDefault();
|
||
var t = 2 * (this.state.down - 1),
|
||
n = [].concat(this.props.value),
|
||
o = this.positionForEvent(e),
|
||
a = r(o, 2),
|
||
i = a[0],
|
||
s = a[1];
|
||
n[t] = this.inversex(i), n[t + 1] = this.inversey(s), this.props.onChange(n)
|
||
}
|
||
}
|
||
},
|
||
onDownUp: {
|
||
value: function() {
|
||
this.setState({
|
||
down: 0
|
||
})
|
||
}
|
||
},
|
||
positionForEvent: {
|
||
value: function(e) {
|
||
var t = c.findDOMNode(this).getBoundingClientRect();
|
||
return [e.clientX - t.left, e.clientY - t.top]
|
||
}
|
||
},
|
||
x: {
|
||
value: function(e) {
|
||
var t = this.props.padding,
|
||
n = this.props.width - t[1] - t[3];
|
||
return Math.round(t[3] + e * n)
|
||
}
|
||
},
|
||
inversex: {
|
||
value: function(e) {
|
||
var t = this.props.padding,
|
||
n = this.props.width - t[1] - t[3];
|
||
return Math.max(0, Math.min((e - t[3]) / n, 1))
|
||
}
|
||
},
|
||
y: {
|
||
value: function(e) {
|
||
var t = this.props.padding,
|
||
n = this.props.height - t[0] - t[2];
|
||
return Math.round(t[0] + (1 - e) * n)
|
||
}
|
||
},
|
||
inversey: {
|
||
value: function(e) {
|
||
var t = this.props,
|
||
n = t.height,
|
||
r = t.handleRadius,
|
||
o = t.padding,
|
||
a = 2 * r,
|
||
i = n - o[0] - o[2];
|
||
return e = Math.max(a, Math.min(e, n - a)), 1 - (e - o[0]) / i
|
||
}
|
||
}
|
||
}), t
|
||
}(d);
|
||
t.exports = E, E.propTypes = y, E.defaultProps = g
|
||
}, {
|
||
"./Curve": 185,
|
||
"./Grid": 186,
|
||
"./Handle": 187,
|
||
"./Progress": 188,
|
||
"object-assign": 6,
|
||
react: 179
|
||
}],
|
||
185: [function(e, t) {
|
||
"use strict";
|
||
var n = function(e) {
|
||
return e && e.__esModule ? e["default"] : e
|
||
},
|
||
r = 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
|
||
}
|
||
}(),
|
||
o = function l(e, t, n) {
|
||
var r = Object.getOwnPropertyDescriptor(e, t);
|
||
if (void 0 === r) {
|
||
var o = Object.getPrototypeOf(e);
|
||
|
||
return null === o ? void 0 : l(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)
|
||
},
|
||
a = 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)
|
||
},
|
||
i = function(e, t) {
|
||
if (!(e instanceof t)) throw new TypeError("Cannot call a class as a function")
|
||
},
|
||
s = n(e("react")),
|
||
u = n(e("./BezierComponent")),
|
||
c = function(e) {
|
||
function t() {
|
||
i(this, t), null != e && e.apply(this, arguments)
|
||
}
|
||
return a(t, e), r(t, {
|
||
shouldComponentUpdate: {
|
||
value: function(e) {
|
||
if (o(Object.getPrototypeOf(t.prototype), "shouldComponentUpdate", this).call(this, e)) return !0;
|
||
var n = this.props,
|
||
r = n.curveColor,
|
||
a = n.curveWidth,
|
||
i = n.value;
|
||
return e.curveColor !== r || e.curveWidth !== a || e.value !== i
|
||
}
|
||
},
|
||
render: {
|
||
value: function() {
|
||
var e = this.props,
|
||
t = e.curveColor,
|
||
n = e.curveWidth,
|
||
r = e.value,
|
||
o = this,
|
||
a = o.x,
|
||
i = o.y,
|
||
u = a(0),
|
||
c = i(0),
|
||
l = a(1),
|
||
p = i(1),
|
||
d = a(r[0]),
|
||
f = i(r[1]),
|
||
h = a(r[2]),
|
||
v = i(r[3]),
|
||
m = ["M" + [u, c], "C" + [d, f], "" + [h, v], "" + [l, p]].join(" ");
|
||
return s.createElement("path", {
|
||
fill: "none",
|
||
stroke: t,
|
||
strokeWidth: n,
|
||
d: m
|
||
})
|
||
}
|
||
}
|
||
}), t
|
||
}(u);
|
||
t.exports = c
|
||
}, {
|
||
"./BezierComponent": 183,
|
||
react: 179
|
||
}],
|
||
186: [function(e, t) {
|
||
"use strict";
|
||
|
||
function n(e, t, n) {
|
||
for (var r = [], o = e; t > o; o += n) r.push(o);
|
||
return r
|
||
}
|
||
|
||
function r(e, t) {
|
||
var n = Object.keys(e),
|
||
r = Object.keys(t);
|
||
if (n.length !== r.length) return !1;
|
||
for (var o in e)
|
||
if (e[o] !== t[o]) return !1;
|
||
return !0
|
||
}
|
||
var o = function(e) {
|
||
return e && e.__esModule ? e["default"] : e
|
||
},
|
||
a = 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
|
||
}
|
||
}(),
|
||
i = 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)
|
||
},
|
||
s = 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)
|
||
},
|
||
u = function(e, t) {
|
||
if (!(e instanceof t)) throw new TypeError("Cannot call a class as a function")
|
||
},
|
||
c = o(e("react")),
|
||
l = o(e("object-assign")),
|
||
p = o(e("./BezierComponent")),
|
||
d = function(e) {
|
||
function t() {
|
||
u(this, t), null != e && e.apply(this, arguments)
|
||
}
|
||
return s(t, e), a(t, {
|
||
gridX: {
|
||
value: function(e) {
|
||
var t = 1 / e;
|
||
return n(0, 1, t).map(this.x)
|
||
}
|
||
},
|
||
gridY: {
|
||
value: function(e) {
|
||
var t = 1 / e;
|
||
return n(0, 1, t).map(this.y)
|
||
}
|
||
},
|
||
shouldComponentUpdate: {
|
||
value: function(e) {
|
||
if (i(Object.getPrototypeOf(t.prototype), "shouldComponentUpdate", this).call(this, e)) return !0;
|
||
var n = this.props,
|
||
o = n.background,
|
||
a = n.gridColor,
|
||
s = n.textStyle;
|
||
return e.background !== o || e.gridColor !== a || !r(e.textStyle, s)
|
||
}
|
||
},
|
||
render: {
|
||
value: function() {
|
||
var e = this,
|
||
t = e.x,
|
||
n = e.y,
|
||
r = this.props,
|
||
o = r.background,
|
||
a = r.gridColor,
|
||
i = r.textStyle,
|
||
s = t(0),
|
||
u = n(0),
|
||
p = t(1),
|
||
d = n(1),
|
||
f = this.gridX(2),
|
||
h = this.gridY(2),
|
||
v = this.gridX(10),
|
||
m = this.gridY(10),
|
||
y = ["M" + [s, u], "L" + [s, d], "L" + [p, d], "L" + [p, u], "Z"].join(" "),
|
||
g = v.map(function(e) {
|
||
return ["M" + [e, u], "L" + [e, d]]
|
||
}).concat(m.map(function(e) {
|
||
return ["M" + [s, e], "L" + [p, e]]
|
||
})).join(" "),
|
||
E = f.map(function(e) {
|
||
return ["M" + [e, u], "L" + [e, d]]
|
||
}).concat(h.map(function(e) {
|
||
return ["M" + [s, e], "L" + [p, e]]
|
||
})).concat(["M" + [s, u], "L" + [p, d]]).join(" "),
|
||
C = m.map(function(e, t) {
|
||
var n = 3 + (t % 5 === 0 ? 2 : 0);
|
||
return ["M" + [s, e], "L" + [s - n, e]]
|
||
}).join(" "),
|
||
b = v.map(function(e, t) {
|
||
var n = 3 + (t % 5 === 0 ? 2 : 0);
|
||
return ["M" + [e, u], "L" + [e, u + n]]
|
||
}).join(" ");
|
||
return c.createElement("g", null, c.createElement("path", {
|
||
fill: o,
|
||
d: y
|
||
}), c.createElement("path", {
|
||
strokeWidth: "1px",
|
||
stroke: a,
|
||
d: g
|
||
}), c.createElement("path", {
|
||
strokeWidth: "2px",
|
||
stroke: a,
|
||
d: E
|
||
}), c.createElement("path", {
|
||
strokeWidth: "1px",
|
||
stroke: a,
|
||
d: C
|
||
}), c.createElement("text", {
|
||
style: l({
|
||
textAnchor: "end"
|
||
}, i),
|
||
transform: "rotate(-90)",
|
||
x: -this.y(1),
|
||
y: this.x(0) - 8
|
||
}, "Axis Easing Output"), c.createElement("path", {
|
||
strokeWidth: "1px",
|
||
stroke: a,
|
||
d: b
|
||
}), c.createElement("text", {
|
||
style: l({
|
||
dominantBaseline: "text-before-edge"
|
||
}, i),
|
||
textAnchor: "end",
|
||
x: this.x(1),
|
||
y: this.y(0) + 5
|
||
}, "Axis Raw Input"))
|
||
}
|
||
}
|
||
}), t
|
||
}(p);
|
||
t.exports = d
|
||
}, {
|
||
"./BezierComponent": 183,
|
||
"object-assign": 6,
|
||
react: 179
|
||
}],
|
||
187: [function(e, t) {
|
||
"use strict";
|
||
var n = function(e) {
|
||
return e && e.__esModule ? e["default"] : e
|
||
},
|
||
r = 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
|
||
}
|
||
}(),
|
||
o = function l(e, t, n) {
|
||
var r = Object.getOwnPropertyDescriptor(e, t);
|
||
if (void 0 === r) {
|
||
var o = Object.getPrototypeOf(e);
|
||
return null === o ? void 0 : l(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)
|
||
},
|
||
a = 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)
|
||
},
|
||
i = function(e, t) {
|
||
if (!(e instanceof t)) throw new TypeError("Cannot call a class as a function")
|
||
},
|
||
s = n(e("react")),
|
||
u = n(e("./BezierComponent")),
|
||
c = function(e) {
|
||
function t() {
|
||
i(this, t), null != e && e.apply(this, arguments)
|
||
}
|
||
return a(t, e), r(t, {
|
||
shouldComponentUpdate: {
|
||
value: function(e) {
|
||
if (o(Object.getPrototypeOf(t.prototype), "shouldComponentUpdate", this).call(this, e)) return !0;
|
||
var n = this.props,
|
||
r = n.index,
|
||
a = n.handleRadius,
|
||
i = n.handleColor,
|
||
s = n.hover,
|
||
u = n.down,
|
||
c = n.background,
|
||
l = n.handleStroke,
|
||
p = n.xval,
|
||
d = n.yval,
|
||
f = n.onMouseEnter,
|
||
h = n.onMouseLeave,
|
||
v = n.onMouseDown;
|
||
return e.index !== r || e.handleRadius !== a || e.handleColor !== i || e.hover !== s || e.down !== u || e.background !== c || e.handleStroke !== l || e.xval !== p || e.yval !== d || e.onMouseDown !== v || e.onMouseLeave !== h || e.onMouseEnter !== f
|
||
}
|
||
},
|
||
render: {
|
||
value: function() {
|
||
var e = this,
|
||
t = e.x,
|
||
n = e.y,
|
||
r = this.props,
|
||
o = r.index,
|
||
a = r.handleRadius,
|
||
i = r.handleColor,
|
||
u = r.hover,
|
||
c = r.down,
|
||
l = r.background,
|
||
p = r.handleStroke,
|
||
d = r.xval,
|
||
f = r.yval,
|
||
h = r.onMouseEnter,
|
||
v = r.onMouseLeave,
|
||
m = r.onMouseDown,
|
||
y = t(o),
|
||
g = n(o),
|
||
E = t(d),
|
||
C = n(f),
|
||
b = Math.atan2(C - g, E - y),
|
||
_ = E - a * Math.cos(b),
|
||
N = C - a * Math.sin(b);
|
||
return s.createElement("g", null, s.createElement("line", {
|
||
stroke: i,
|
||
strokeWidth: u || c ? 1 + p : p,
|
||
x1: _,
|
||
y1: N,
|
||
x2: y,
|
||
y2: g
|
||
}), s.createElement("circle", {
|
||
cx: E,
|
||
cy: C,
|
||
r: a,
|
||
stroke: i,
|
||
strokeWidth: u || c ? 2+p : p,
|
||
fill: c ? l : i,
|
||
onMouseEnter: h,
|
||
onMouseLeave: v,
|
||
onMouseDown: m
|
||
}))
|
||
}
|
||
}
|
||
}), t
|
||
}(u);
|
||
t.exports = c
|
||
}, {
|
||
"./BezierComponent": 183,
|
||
react: 179
|
||
}],
|
||
188: [function(e, t) {
|
||
"use strict";
|
||
var n = function(e) {
|
||
return e && e.__esModule ? e["default"] : e
|
||
},
|
||
r = 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
|
||
}
|
||
}(),
|
||
o = function p(e, t, n) {
|
||
var r = Object.getOwnPropertyDescriptor(e, t);
|
||
if (void 0 === r) {
|
||
var o = Object.getPrototypeOf(e);
|
||
return null === o ? void 0 : p(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)
|
||
},
|
||
a = 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)
|
||
},
|
||
i = function(e, t) {
|
||
if (!(e instanceof t)) throw new TypeError("Cannot call a class as a function")
|
||
},
|
||
s = n(e("react")),
|
||
u = n(e("bezier-easing")),
|
||
c = n(e("./BezierComponent")),
|
||
l = function(e) {
|
||
function t(e) {
|
||
i(this, t), o(Object.getPrototypeOf(t.prototype), "constructor", this).call(this, e), this.genEasing(e.value)
|
||
}
|
||
return a(t, e), r(t, {
|
||
genEasing: {
|
||
value: function(e) {
|
||
this.easing = u.apply(null, e)
|
||
}
|
||
},
|
||
shouldComponentUpdate: {
|
||
value: function(e) {
|
||
if (o(Object.getPrototypeOf(t.prototype), "shouldComponentUpdate", this).call(this, e)) return !0;
|
||
var n = this.props,
|
||
r = n.value,
|
||
a = n.progress,
|
||
i = n.progressColor;
|
||
return e.progress !== a || e.progressColor !== i || e.value !== r
|
||
}
|
||
},
|
||
componentWillUpdate: {
|
||
value: function(e) {
|
||
this.props.value !== e.value && this.genEasing(e.value)
|
||
}
|
||
},
|
||
render: {
|
||
value: function() {
|
||
var e = this.props,
|
||
t = e.progress,
|
||
n = e.progressColor;
|
||
if (!t) return s.createElement("path", null);
|
||
var r = this.x(0)-8,
|
||
o = this.y(0)+8,
|
||
a = this.x(t),
|
||
i = this.y(this.easing ? this.easing(t) : 0),
|
||
u = ["M" + [a, o], "L" + [a, i], "L" + [r, i]].join(" ");
|
||
return s.createElement("path", {
|
||
fill: "none",
|
||
strokeWidth: "1px",
|
||
stroke: n,
|
||
d: u
|
||
})
|
||
}
|
||
}
|
||
}), t
|
||
}(c);
|
||
t.exports = l
|
||
}, {
|
||
"./BezierComponent": 183,
|
||
"bezier-easing": 5,
|
||
react: 179
|
||
}],
|
||
189: [function(e, t) {
|
||
"use strict";
|
||
var n = function(e) {
|
||
return e && e.__esModule ? e["default"] : e
|
||
},
|
||
r = n(e("./BezierEditor")),
|
||
o = n(e("uncontrollable"));
|
||
t.exports = o(r, {
|
||
value: "onChange"
|
||
})
|
||
}, {
|
||
"./BezierEditor": 184,
|
||
uncontrollable: 180
|
||
}]
|
||
}, {}, [1]);
|