15655 lines
704 KiB
JavaScript
15655 lines
704 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 = 0.001,
|
||
o = 1e-7,
|
||
a = 10,
|
||
i = 11,
|
||
s = 1 / (i - 1),
|
||
u = "Float32Array" in t;
|
||
return (
|
||
(e.css = {
|
||
ease: e(0.25, 0.1, 0.25, 1),
|
||
linear: e(0, 0, 1, 1),
|
||
"ease-in": e(0.42, 0, 1, 1),
|
||
"ease-out": e(0, 0, 0.58, 1),
|
||
"ease-in-out": e(0.42, 0, 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: [0.25, 0.25, 0.75, 0.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],
|
||
);
|