From 42e11272d4fc5811021f4734b37fd40ed633e899 Mon Sep 17 00:00:00 2001 From: Rim Date: Wed, 23 Apr 2025 07:27:08 -0400 Subject: [PATCH] init --- .gitmodules | 9 + ds4windows/Actions.xml | 10 + ds4windows/BezierCurveEditor/build.js | 14315 ++++++++++++++++ ds4windows/BezierCurveEditor/index.html | 10 + ds4windows/ControllerConfigs.xml | 4 + ds4windows/DS4Updater.exe | Bin 0 -> 826855 bytes ds4windows/DS4Windows.deps.json | 500 + ds4windows/DS4Windows.dll | Bin 0 -> 4169728 bytes ds4windows/DS4Windows.exe | Bin 0 -> 559104 bytes ds4windows/DS4Windows.runtimeconfig.json | 21 + .../DependencyPropertyGenerator.Core.dll | Bin 0 -> 41472 bytes .../DotNetProjects.Wpf.Extended.Toolkit.dll | Bin 0 -> 1198080 bytes ds4windows/FakerInputDll.dll | Bin 0 -> 14848 bytes ds4windows/FakerInputWrapper.dll | Bin 0 -> 10752 bytes ds4windows/H.NotifyIcon.Wpf.dll | Bin 0 -> 109568 bytes ds4windows/H.NotifyIcon.dll | Bin 0 -> 339456 bytes ds4windows/HidHide Configuration Client.lnk | Bin 0 -> 1349 bytes ds4windows/HidHide_1.2.128_x64.exe | Bin 0 -> 5228136 bytes ds4windows/HttpProgress.dll | Bin 0 -> 13824 bytes ds4windows/ICSharpCode.AvalonEdit.dll | Bin 0 -> 616960 bytes ds4windows/Lang/ar/DS4Windows.resources.dll | Bin 0 -> 11776 bytes ds4windows/Lang/cs/DS4Windows.resources.dll | Bin 0 -> 11776 bytes ds4windows/Lang/de/DS4Windows.resources.dll | Bin 0 -> 19968 bytes ...icrosoft.Win32.TaskScheduler.resources.dll | Bin 0 -> 9728 bytes ds4windows/Lang/el/DS4Windows.resources.dll | Bin 0 -> 35328 bytes ds4windows/Lang/es/DS4Windows.resources.dll | Bin 0 -> 10752 bytes ...icrosoft.Win32.TaskScheduler.resources.dll | Bin 0 -> 10240 bytes ds4windows/Lang/fi/DS4Windows.resources.dll | Bin 0 -> 22528 bytes ds4windows/Lang/fr/DS4Windows.resources.dll | Bin 0 -> 24576 bytes ...icrosoft.Win32.TaskScheduler.resources.dll | Bin 0 -> 10240 bytes ds4windows/Lang/he/DS4Windows.resources.dll | Bin 0 -> 11264 bytes .../Lang/hu-HU/DS4Windows.resources.dll | Bin 0 -> 10752 bytes ds4windows/Lang/it/DS4Windows.resources.dll | Bin 0 -> 21504 bytes ...icrosoft.Win32.TaskScheduler.resources.dll | Bin 0 -> 10240 bytes ds4windows/Lang/ja/DS4Windows.resources.dll | Bin 0 -> 19968 bytes ds4windows/Lang/ms/DS4Windows.resources.dll | Bin 0 -> 25088 bytes ds4windows/Lang/nl/DS4Windows.resources.dll | Bin 0 -> 38912 bytes ds4windows/Lang/pl/DS4Windows.resources.dll | Bin 0 -> 10752 bytes ...icrosoft.Win32.TaskScheduler.resources.dll | Bin 0 -> 10240 bytes .../Lang/pt-BR/DS4Windows.resources.dll | Bin 0 -> 10752 bytes ds4windows/Lang/pt/DS4Windows.resources.dll | Bin 0 -> 11776 bytes ds4windows/Lang/ru/DS4Windows.resources.dll | Bin 0 -> 814080 bytes ...icrosoft.Win32.TaskScheduler.resources.dll | Bin 0 -> 10752 bytes ds4windows/Lang/se/DS4Windows.resources.dll | Bin 0 -> 16896 bytes ds4windows/Lang/tr/DS4Windows.resources.dll | Bin 0 -> 26112 bytes .../Lang/uk-UA/DS4Windows.resources.dll | Bin 0 -> 11264 bytes ds4windows/Lang/vi/DS4Windows.resources.dll | Bin 0 -> 23552 bytes .../Lang/zh-CN/DS4Windows.resources.dll | Bin 0 -> 10240 bytes ...icrosoft.Win32.TaskScheduler.resources.dll | Bin 0 -> 9728 bytes .../Lang/zh-Hans/DS4Windows.resources.dll | Bin 0 -> 48640 bytes .../Lang/zh-Hant/DS4Windows.resources.dll | Bin 0 -> 16896 bytes ...icrosoft.Win32.TaskScheduler.resources.dll | Bin 0 -> 9728 bytes .../Lang/zh-TW/DS4Windows.resources.dll | Bin 0 -> 11264 bytes ds4windows/MdXaml.Plugins.dll | Bin 0 -> 8704 bytes ds4windows/MdXaml.dll | Bin 0 -> 125952 bytes ds4windows/Microsoft.Win32.TaskScheduler.dll | Bin 0 -> 336896 bytes ds4windows/NLog.config | 17 + ds4windows/NLog.dll | Bin 0 -> 837120 bytes .../Nefarius.Utilities.DeviceManagement.dll | Bin 0 -> 269312 bytes ds4windows/Nefarius.ViGEm.Client.dll | Bin 0 -> 213504 bytes ds4windows/Ookii.Dialogs.Wpf.dll | Bin 0 -> 105984 bytes ds4windows/OutputSlots.xml | 4 + ds4windows/SharpOSC.dll | Bin 0 -> 19968 bytes ds4windows/System.CodeDom.dll | Bin 0 -> 187520 bytes ds4windows/System.Management.dll | Bin 0 -> 74352 bytes .../Tools/XInputChecker/SharpDX.XInput.dll | Bin 0 -> 13824 bytes ds4windows/Tools/XInputChecker/SharpDX.dll | Bin 0 -> 275968 bytes .../XInputChecker/XInputChecker.deps.json | 1240 ++ .../Tools/XInputChecker/XInputChecker.dll | Bin 0 -> 38912 bytes .../Tools/XInputChecker/XInputChecker.exe | Bin 0 -> 160768 bytes .../XInputChecker.runtimeconfig.json | 20 + .../ViGEmBus_1.21.442_x64_x86_arm64.exe | Bin 0 -> 6288904 bytes ds4windows/WPFLocalizeExtension.dll | Bin 0 -> 90624 bytes ds4windows/WpfScreenHelper.dll | Bin 0 -> 17920 bytes ds4windows/XAMLMarkupExtensions.dll | Bin 0 -> 36864 bytes .../win/lib/net6.0/System.Management.dll | Bin 0 -> 295552 bytes .../win/lib/net7.0/System.Management.dll | Bin 0 -> 295600 bytes dualshock-tools | 1 + gamepad-tester | 1 + gamepad-viewer | 1 + hidusbf/README.md | 346 + hidusbf/check_hidusbf_running.cmd | 6 + hidusbf/hidusbf.zip | Bin 0 -> 373234 bytes hidusbf/hidusbf/DRIVER/1kHz.cmd | 4 + hidusbf/hidusbf/DRIVER/2kHz-4kHz.cmd | 4 + hidusbf/hidusbf/DRIVER/4kHz-8kHz.cmd | 4 + hidusbf/hidusbf/DRIVER/98ME/hidusbf.sys | Bin 0 -> 3616 bytes hidusbf/hidusbf/DRIVER/AMD64/1khz/hidusbf.sys | Bin 0 -> 25288 bytes .../DRIVER/AMD64/2khz-4khz/hidusbf.sys | Bin 0 -> 25288 bytes .../DRIVER/AMD64/4khz-8khz/hidusbf.sys | Bin 0 -> 25288 bytes hidusbf/hidusbf/DRIVER/AMD64/hidusbf.sys | Bin 0 -> 25288 bytes .../hidusbf/DRIVER/AMD64/nopatch/hidusbf.sys | Bin 0 -> 23368 bytes hidusbf/hidusbf/DRIVER/HIDUSBF.INF | 62 + hidusbf/hidusbf/DRIVER/HIDUSBFU.INF | 41 + hidusbf/hidusbf/DRIVER/NTX86/1khz/hidusbf.sys | Bin 0 -> 23368 bytes .../DRIVER/NTX86/2khz-4khz/hidusbf.sys | Bin 0 -> 23496 bytes .../DRIVER/NTX86/4khz-8khz/hidusbf.sys | Bin 0 -> 23496 bytes hidusbf/hidusbf/DRIVER/NTX86/hidusbf.sys | Bin 0 -> 23368 bytes .../hidusbf/DRIVER/NTX86/nopatch/hidusbf.sys | Bin 0 -> 21216 bytes hidusbf/hidusbf/DRIVER/Setup.exe | Bin 0 -> 405008 bytes hidusbf/hidusbf/DRIVER/nopatch.cmd | 4 + hidusbf/hidusbf/DRIVER/sx64.exe | Bin 0 -> 51384 bytes hidusbf/hidusbf/README.2kHz-8kHz.ENG.TXT | 22 + hidusbf/hidusbf/README.ENG.TXT | 329 + hidusbf/hidusbf/README.RUS.TXT | 337 + hidusbf/hidusbfn.zip | Bin 0 -> 115838 bytes init.bat | 1 + init.sh | 3 + xinput-test/XInputTest_1000_Samples.exe | Bin 0 -> 52224 bytes xinput-test/XInputTest_2000_Samples.exe | Bin 0 -> 52224 bytes xinput-test/XInputTest_4000_Samples.exe | Bin 0 -> 52224 bytes 111 files changed, 17316 insertions(+) create mode 100644 .gitmodules create mode 100644 ds4windows/Actions.xml create mode 100644 ds4windows/BezierCurveEditor/build.js create mode 100644 ds4windows/BezierCurveEditor/index.html create mode 100644 ds4windows/ControllerConfigs.xml create mode 100644 ds4windows/DS4Updater.exe create mode 100644 ds4windows/DS4Windows.deps.json create mode 100644 ds4windows/DS4Windows.dll create mode 100644 ds4windows/DS4Windows.exe create mode 100644 ds4windows/DS4Windows.runtimeconfig.json create mode 100644 ds4windows/DependencyPropertyGenerator.Core.dll create mode 100644 ds4windows/DotNetProjects.Wpf.Extended.Toolkit.dll create mode 100644 ds4windows/FakerInputDll.dll create mode 100644 ds4windows/FakerInputWrapper.dll create mode 100644 ds4windows/H.NotifyIcon.Wpf.dll create mode 100644 ds4windows/H.NotifyIcon.dll create mode 100644 ds4windows/HidHide Configuration Client.lnk create mode 100644 ds4windows/HidHide_1.2.128_x64.exe create mode 100644 ds4windows/HttpProgress.dll create mode 100644 ds4windows/ICSharpCode.AvalonEdit.dll create mode 100644 ds4windows/Lang/ar/DS4Windows.resources.dll create mode 100644 ds4windows/Lang/cs/DS4Windows.resources.dll create mode 100644 ds4windows/Lang/de/DS4Windows.resources.dll create mode 100644 ds4windows/Lang/de/Microsoft.Win32.TaskScheduler.resources.dll create mode 100644 ds4windows/Lang/el/DS4Windows.resources.dll create mode 100644 ds4windows/Lang/es/DS4Windows.resources.dll create mode 100644 ds4windows/Lang/es/Microsoft.Win32.TaskScheduler.resources.dll create mode 100644 ds4windows/Lang/fi/DS4Windows.resources.dll create mode 100644 ds4windows/Lang/fr/DS4Windows.resources.dll create mode 100644 ds4windows/Lang/fr/Microsoft.Win32.TaskScheduler.resources.dll create mode 100644 ds4windows/Lang/he/DS4Windows.resources.dll create mode 100644 ds4windows/Lang/hu-HU/DS4Windows.resources.dll create mode 100644 ds4windows/Lang/it/DS4Windows.resources.dll create mode 100644 ds4windows/Lang/it/Microsoft.Win32.TaskScheduler.resources.dll create mode 100644 ds4windows/Lang/ja/DS4Windows.resources.dll create mode 100644 ds4windows/Lang/ms/DS4Windows.resources.dll create mode 100644 ds4windows/Lang/nl/DS4Windows.resources.dll create mode 100644 ds4windows/Lang/pl/DS4Windows.resources.dll create mode 100644 ds4windows/Lang/pl/Microsoft.Win32.TaskScheduler.resources.dll create mode 100644 ds4windows/Lang/pt-BR/DS4Windows.resources.dll create mode 100644 ds4windows/Lang/pt/DS4Windows.resources.dll create mode 100644 ds4windows/Lang/ru/DS4Windows.resources.dll create mode 100644 ds4windows/Lang/ru/Microsoft.Win32.TaskScheduler.resources.dll create mode 100644 ds4windows/Lang/se/DS4Windows.resources.dll create mode 100644 ds4windows/Lang/tr/DS4Windows.resources.dll create mode 100644 ds4windows/Lang/uk-UA/DS4Windows.resources.dll create mode 100644 ds4windows/Lang/vi/DS4Windows.resources.dll create mode 100644 ds4windows/Lang/zh-CN/DS4Windows.resources.dll create mode 100644 ds4windows/Lang/zh-CN/Microsoft.Win32.TaskScheduler.resources.dll create mode 100644 ds4windows/Lang/zh-Hans/DS4Windows.resources.dll create mode 100644 ds4windows/Lang/zh-Hant/DS4Windows.resources.dll create mode 100644 ds4windows/Lang/zh-Hant/Microsoft.Win32.TaskScheduler.resources.dll create mode 100644 ds4windows/Lang/zh-TW/DS4Windows.resources.dll create mode 100644 ds4windows/MdXaml.Plugins.dll create mode 100644 ds4windows/MdXaml.dll create mode 100644 ds4windows/Microsoft.Win32.TaskScheduler.dll create mode 100644 ds4windows/NLog.config create mode 100644 ds4windows/NLog.dll create mode 100644 ds4windows/Nefarius.Utilities.DeviceManagement.dll create mode 100644 ds4windows/Nefarius.ViGEm.Client.dll create mode 100644 ds4windows/Ookii.Dialogs.Wpf.dll create mode 100644 ds4windows/OutputSlots.xml create mode 100644 ds4windows/SharpOSC.dll create mode 100644 ds4windows/System.CodeDom.dll create mode 100644 ds4windows/System.Management.dll create mode 100644 ds4windows/Tools/XInputChecker/SharpDX.XInput.dll create mode 100644 ds4windows/Tools/XInputChecker/SharpDX.dll create mode 100644 ds4windows/Tools/XInputChecker/XInputChecker.deps.json create mode 100644 ds4windows/Tools/XInputChecker/XInputChecker.dll create mode 100644 ds4windows/Tools/XInputChecker/XInputChecker.exe create mode 100644 ds4windows/Tools/XInputChecker/XInputChecker.runtimeconfig.json create mode 100644 ds4windows/ViGEmBus_1.21.442_x64_x86_arm64.exe create mode 100644 ds4windows/WPFLocalizeExtension.dll create mode 100644 ds4windows/WpfScreenHelper.dll create mode 100644 ds4windows/XAMLMarkupExtensions.dll create mode 100644 ds4windows/runtimes/win/lib/net6.0/System.Management.dll create mode 100644 ds4windows/runtimes/win/lib/net7.0/System.Management.dll create mode 160000 dualshock-tools create mode 160000 gamepad-tester create mode 160000 gamepad-viewer create mode 100644 hidusbf/README.md create mode 100644 hidusbf/check_hidusbf_running.cmd create mode 100644 hidusbf/hidusbf.zip create mode 100644 hidusbf/hidusbf/DRIVER/1kHz.cmd create mode 100644 hidusbf/hidusbf/DRIVER/2kHz-4kHz.cmd create mode 100644 hidusbf/hidusbf/DRIVER/4kHz-8kHz.cmd create mode 100644 hidusbf/hidusbf/DRIVER/98ME/hidusbf.sys create mode 100644 hidusbf/hidusbf/DRIVER/AMD64/1khz/hidusbf.sys create mode 100644 hidusbf/hidusbf/DRIVER/AMD64/2khz-4khz/hidusbf.sys create mode 100644 hidusbf/hidusbf/DRIVER/AMD64/4khz-8khz/hidusbf.sys create mode 100644 hidusbf/hidusbf/DRIVER/AMD64/hidusbf.sys create mode 100644 hidusbf/hidusbf/DRIVER/AMD64/nopatch/hidusbf.sys create mode 100644 hidusbf/hidusbf/DRIVER/HIDUSBF.INF create mode 100644 hidusbf/hidusbf/DRIVER/HIDUSBFU.INF create mode 100644 hidusbf/hidusbf/DRIVER/NTX86/1khz/hidusbf.sys create mode 100644 hidusbf/hidusbf/DRIVER/NTX86/2khz-4khz/hidusbf.sys create mode 100644 hidusbf/hidusbf/DRIVER/NTX86/4khz-8khz/hidusbf.sys create mode 100644 hidusbf/hidusbf/DRIVER/NTX86/hidusbf.sys create mode 100644 hidusbf/hidusbf/DRIVER/NTX86/nopatch/hidusbf.sys create mode 100644 hidusbf/hidusbf/DRIVER/Setup.exe create mode 100644 hidusbf/hidusbf/DRIVER/nopatch.cmd create mode 100644 hidusbf/hidusbf/DRIVER/sx64.exe create mode 100644 hidusbf/hidusbf/README.2kHz-8kHz.ENG.TXT create mode 100644 hidusbf/hidusbf/README.ENG.TXT create mode 100644 hidusbf/hidusbf/README.RUS.TXT create mode 100644 hidusbf/hidusbfn.zip create mode 100644 init.bat create mode 100644 init.sh create mode 100644 xinput-test/XInputTest_1000_Samples.exe create mode 100644 xinput-test/XInputTest_2000_Samples.exe create mode 100644 xinput-test/XInputTest_4000_Samples.exe diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000..d900ecd --- /dev/null +++ b/.gitmodules @@ -0,0 +1,9 @@ +[submodule "gamepad-viewer"] + path = gamepad-viewer + url = https://github.com/Ahrimdon/gamepad-viewer +[submodule "gamepad-tester"] + path = gamepad-tester + url = https://github.com/Ahrimdon/gamepad-tester +[submodule "dualshock-tools"] + path = dualshock-tools + url = https://github.com/Ahrimdon/dualshock-tools diff --git a/ds4windows/Actions.xml b/ds4windows/Actions.xml new file mode 100644 index 0000000..b7a8dfd --- /dev/null +++ b/ds4windows/Actions.xml @@ -0,0 +1,10 @@ + + + + + + PS/Options + DisconnectBT +
0
+ + \ No newline at end of file diff --git a/ds4windows/BezierCurveEditor/build.js b/ds4windows/BezierCurveEditor/build.js new file mode 100644 index 0000000..bc359a3 --- /dev/null +++ b/ds4windows/BezierCurveEditor/build.js @@ -0,0 +1,14315 @@ +!(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:�", + i.createElement( + "code", + null, + this.state.value + .map(function (e) { + return e.toFixed(2); + }) + .join(", "), + ), + i.createElement("br", null), + "progress:�", + 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 when using tables, nesting tags like
,

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