diff --git a/.DS_Store b/.DS_Store index 82a9710..11ad1bb 100644 Binary files a/.DS_Store and b/.DS_Store differ diff --git a/GWTReactApp/.DS_Store b/GWTReactApp/.DS_Store new file mode 100644 index 0000000..820f04a Binary files /dev/null and b/GWTReactApp/.DS_Store differ diff --git a/GWTReactApp/.classpath b/GWTReactApp/.classpath new file mode 100644 index 0000000..50125a6 --- /dev/null +++ b/GWTReactApp/.classpath @@ -0,0 +1,12 @@ + + + + + + + + + + + + diff --git a/GWTReactApp/.project b/GWTReactApp/.project new file mode 100644 index 0000000..e280283 --- /dev/null +++ b/GWTReactApp/.project @@ -0,0 +1,34 @@ + + + GWTReactApp + + + + + + org.eclipse.wst.common.project.facet.core.builder + + + + + org.eclipse.jdt.core.javabuilder + + + + + com.google.gdt.eclipse.core.webAppProjectValidator + + + + + com.google.gwt.eclipse.core.gwtProjectValidator + + + + + + org.eclipse.jdt.core.javanature + com.google.gwt.eclipse.core.gwtNature + org.eclipse.wst.common.project.facet.core.nature + + diff --git a/GWTReactApp/.settings/com.google.gdt.eclipse.core.prefs b/GWTReactApp/.settings/com.google.gdt.eclipse.core.prefs new file mode 100644 index 0000000..cc6cb35 --- /dev/null +++ b/GWTReactApp/.settings/com.google.gdt.eclipse.core.prefs @@ -0,0 +1,3 @@ +eclipse.preferences.version=1 +warSrcDir=war +warSrcDirIsOutput=true diff --git a/GWTReactApp/.settings/com.google.gwt.eclipse.core.prefs b/GWTReactApp/.settings/com.google.gwt.eclipse.core.prefs new file mode 100644 index 0000000..077314c --- /dev/null +++ b/GWTReactApp/.settings/com.google.gwt.eclipse.core.prefs @@ -0,0 +1,2 @@ +eclipse.preferences.version=1 +filesCopiedToWebInfLib=gwt-servlet.jar diff --git a/GWTReactApp/.settings/org.eclipse.jdt.core.prefs b/GWTReactApp/.settings/org.eclipse.jdt.core.prefs new file mode 100644 index 0000000..0c68a61 --- /dev/null +++ b/GWTReactApp/.settings/org.eclipse.jdt.core.prefs @@ -0,0 +1,7 @@ +eclipse.preferences.version=1 +org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled +org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8 +org.eclipse.jdt.core.compiler.compliance=1.8 +org.eclipse.jdt.core.compiler.problem.assertIdentifier=error +org.eclipse.jdt.core.compiler.problem.enumIdentifier=error +org.eclipse.jdt.core.compiler.source=1.8 diff --git a/GWTReactApp/.settings/org.eclipse.wst.common.project.facet.core.xml b/GWTReactApp/.settings/org.eclipse.wst.common.project.facet.core.xml new file mode 100644 index 0000000..f4ef8aa --- /dev/null +++ b/GWTReactApp/.settings/org.eclipse.wst.common.project.facet.core.xml @@ -0,0 +1,4 @@ + + + + diff --git a/GWTReactApp/gwt-unitCache/gwt-unitCache-a16975ef896ee526cd067ad8f9dd16d040e74002-FF35F588CF7564DE259004F02565B00E-0000015CC49AC808 b/GWTReactApp/gwt-unitCache/gwt-unitCache-a16975ef896ee526cd067ad8f9dd16d040e74002-FF35F588CF7564DE259004F02565B00E-0000015CC49AC808 new file mode 100644 index 0000000..c00e23d Binary files /dev/null and b/GWTReactApp/gwt-unitCache/gwt-unitCache-a16975ef896ee526cd067ad8f9dd16d040e74002-FF35F588CF7564DE259004F02565B00E-0000015CC49AC808 differ diff --git a/GWTReactApp/gwt-unitCache/gwt-unitCache-a16975ef896ee526cd067ad8f9dd16d040e74002-FF35F588CF7564DE259004F02565B00E-0000015CC49DF067 b/GWTReactApp/gwt-unitCache/gwt-unitCache-a16975ef896ee526cd067ad8f9dd16d040e74002-FF35F588CF7564DE259004F02565B00E-0000015CC49DF067 new file mode 100644 index 0000000..32bc013 Binary files /dev/null and b/GWTReactApp/gwt-unitCache/gwt-unitCache-a16975ef896ee526cd067ad8f9dd16d040e74002-FF35F588CF7564DE259004F02565B00E-0000015CC49DF067 differ diff --git a/GWTReactApp/gwt-unitCache/gwt-unitCache-a16975ef896ee526cd067ad8f9dd16d040e74002-FF35F588CF7564DE259004F02565B00E-0000015CC4A08FDF b/GWTReactApp/gwt-unitCache/gwt-unitCache-a16975ef896ee526cd067ad8f9dd16d040e74002-FF35F588CF7564DE259004F02565B00E-0000015CC4A08FDF new file mode 100644 index 0000000..af8cb49 Binary files /dev/null and b/GWTReactApp/gwt-unitCache/gwt-unitCache-a16975ef896ee526cd067ad8f9dd16d040e74002-FF35F588CF7564DE259004F02565B00E-0000015CC4A08FDF differ diff --git a/GWTReactApp/gwt-unitCache/gwt-unitCache-a16975ef896ee526cd067ad8f9dd16d040e74002-FF35F588CF7564DE259004F02565B00E-0000015CC4A1C324 b/GWTReactApp/gwt-unitCache/gwt-unitCache-a16975ef896ee526cd067ad8f9dd16d040e74002-FF35F588CF7564DE259004F02565B00E-0000015CC4A1C324 new file mode 100644 index 0000000..fbe5e27 Binary files /dev/null and b/GWTReactApp/gwt-unitCache/gwt-unitCache-a16975ef896ee526cd067ad8f9dd16d040e74002-FF35F588CF7564DE259004F02565B00E-0000015CC4A1C324 differ diff --git a/GWTReactApp/gwt-unitCache/gwt-unitCache-a16975ef896ee526cd067ad8f9dd16d040e74002-FF35F588CF7564DE259004F02565B00E-0000015CC4A996B9 b/GWTReactApp/gwt-unitCache/gwt-unitCache-a16975ef896ee526cd067ad8f9dd16d040e74002-FF35F588CF7564DE259004F02565B00E-0000015CC4A996B9 new file mode 100644 index 0000000..5ae3357 Binary files /dev/null and b/GWTReactApp/gwt-unitCache/gwt-unitCache-a16975ef896ee526cd067ad8f9dd16d040e74002-FF35F588CF7564DE259004F02565B00E-0000015CC4A996B9 differ diff --git a/GWTReactApp/gwt-unitCache/gwt-unitCache-a16975ef896ee526cd067ad8f9dd16d040e74002-FF35F588CF7564DE259004F02565B00E-0000015CC4BAAD14 b/GWTReactApp/gwt-unitCache/gwt-unitCache-a16975ef896ee526cd067ad8f9dd16d040e74002-FF35F588CF7564DE259004F02565B00E-0000015CC4BAAD14 new file mode 100644 index 0000000..e824951 Binary files /dev/null and b/GWTReactApp/gwt-unitCache/gwt-unitCache-a16975ef896ee526cd067ad8f9dd16d040e74002-FF35F588CF7564DE259004F02565B00E-0000015CC4BAAD14 differ diff --git a/GWTReactApp/gwt-unitCache/gwt-unitCache-a16975ef896ee526cd067ad8f9dd16d040e74002-FF35F588CF7564DE259004F02565B00E-0000015CC4BDF24C b/GWTReactApp/gwt-unitCache/gwt-unitCache-a16975ef896ee526cd067ad8f9dd16d040e74002-FF35F588CF7564DE259004F02565B00E-0000015CC4BDF24C new file mode 100644 index 0000000..5addc97 Binary files /dev/null and b/GWTReactApp/gwt-unitCache/gwt-unitCache-a16975ef896ee526cd067ad8f9dd16d040e74002-FF35F588CF7564DE259004F02565B00E-0000015CC4BDF24C differ diff --git a/GWTReactApp/gwt-unitCache/gwt-unitCache-a16975ef896ee526cd067ad8f9dd16d040e74002-FF35F588CF7564DE259004F02565B00E-0000015CC4C12443 b/GWTReactApp/gwt-unitCache/gwt-unitCache-a16975ef896ee526cd067ad8f9dd16d040e74002-FF35F588CF7564DE259004F02565B00E-0000015CC4C12443 new file mode 100644 index 0000000..29d76db Binary files /dev/null and b/GWTReactApp/gwt-unitCache/gwt-unitCache-a16975ef896ee526cd067ad8f9dd16d040e74002-FF35F588CF7564DE259004F02565B00E-0000015CC4C12443 differ diff --git a/GWTReactApp/gwt-unitCache/gwt-unitCache-a16975ef896ee526cd067ad8f9dd16d040e74002-FF35F588CF7564DE259004F02565B00E-0000015CC4CC8A05 b/GWTReactApp/gwt-unitCache/gwt-unitCache-a16975ef896ee526cd067ad8f9dd16d040e74002-FF35F588CF7564DE259004F02565B00E-0000015CC4CC8A05 new file mode 100644 index 0000000..47b4707 Binary files /dev/null and b/GWTReactApp/gwt-unitCache/gwt-unitCache-a16975ef896ee526cd067ad8f9dd16d040e74002-FF35F588CF7564DE259004F02565B00E-0000015CC4CC8A05 differ diff --git a/GWTReactApp/gwt-unitCache/gwt-unitCache-a16975ef896ee526cd067ad8f9dd16d040e74002-FF35F588CF7564DE259004F02565B00E-0000015CC4CE6959 b/GWTReactApp/gwt-unitCache/gwt-unitCache-a16975ef896ee526cd067ad8f9dd16d040e74002-FF35F588CF7564DE259004F02565B00E-0000015CC4CE6959 new file mode 100644 index 0000000..3a11938 Binary files /dev/null and b/GWTReactApp/gwt-unitCache/gwt-unitCache-a16975ef896ee526cd067ad8f9dd16d040e74002-FF35F588CF7564DE259004F02565B00E-0000015CC4CE6959 differ diff --git a/GWTReactApp/gwt-unitCache/gwt-unitCache-a16975ef896ee526cd067ad8f9dd16d040e74002-FF35F588CF7564DE259004F02565B00E-0000015CC4CFBB06 b/GWTReactApp/gwt-unitCache/gwt-unitCache-a16975ef896ee526cd067ad8f9dd16d040e74002-FF35F588CF7564DE259004F02565B00E-0000015CC4CFBB06 new file mode 100644 index 0000000..7b6cfca Binary files /dev/null and b/GWTReactApp/gwt-unitCache/gwt-unitCache-a16975ef896ee526cd067ad8f9dd16d040e74002-FF35F588CF7564DE259004F02565B00E-0000015CC4CFBB06 differ diff --git a/GWTReactApp/src/.DS_Store b/GWTReactApp/src/.DS_Store new file mode 100644 index 0000000..040263c Binary files /dev/null and b/GWTReactApp/src/.DS_Store differ diff --git a/GWTReactApp/src/com/.DS_Store b/GWTReactApp/src/com/.DS_Store new file mode 100644 index 0000000..732e027 Binary files /dev/null and b/GWTReactApp/src/com/.DS_Store differ diff --git a/GWTReactApp/src/com/gwt/.DS_Store b/GWTReactApp/src/com/gwt/.DS_Store new file mode 100644 index 0000000..f821ecf Binary files /dev/null and b/GWTReactApp/src/com/gwt/.DS_Store differ diff --git a/GWTReactApp/src/com/gwt/app/.DS_Store b/GWTReactApp/src/com/gwt/app/.DS_Store new file mode 100644 index 0000000..18d4d31 Binary files /dev/null and b/GWTReactApp/src/com/gwt/app/.DS_Store differ diff --git a/GWTReactApp/src/com/gwt/app/GWTReactApp.gwt.xml b/GWTReactApp/src/com/gwt/app/GWTReactApp.gwt.xml new file mode 100644 index 0000000..7240119 --- /dev/null +++ b/GWTReactApp/src/com/gwt/app/GWTReactApp.gwt.xml @@ -0,0 +1,36 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/GWTReactApp/src/com/gwt/app/client/.DS_Store b/GWTReactApp/src/com/gwt/app/client/.DS_Store new file mode 100644 index 0000000..4ea7363 Binary files /dev/null and b/GWTReactApp/src/com/gwt/app/client/.DS_Store differ diff --git a/GWTReactApp/src/com/gwt/app/client/GWTReactApp.java b/GWTReactApp/src/com/gwt/app/client/GWTReactApp.java new file mode 100644 index 0000000..ab23f4a --- /dev/null +++ b/GWTReactApp/src/com/gwt/app/client/GWTReactApp.java @@ -0,0 +1,238 @@ +package com.gwt.app.client; + +import com.gwt.app.client.components.EmbeddedReact; +import com.gwt.app.shared.UserDTO; +import java.util.Date; +import com.google.gwt.core.client.EntryPoint; +import com.google.gwt.core.client.GWT; +import com.google.gwt.dom.client.Document; +import com.google.gwt.event.dom.client.ClickEvent; +import com.google.gwt.event.dom.client.ClickHandler; +import com.google.gwt.event.dom.client.KeyCodes; +import com.google.gwt.event.dom.client.KeyUpEvent; +import com.google.gwt.event.dom.client.KeyUpHandler; +import com.google.gwt.user.client.Cookies; +import com.google.gwt.user.client.Window; +import com.google.gwt.user.client.rpc.AsyncCallback; +import com.google.gwt.user.client.ui.Button; +import com.google.gwt.user.client.ui.Label; +import com.google.gwt.user.client.ui.PasswordTextBox; +import com.google.gwt.user.client.ui.RootPanel; +import com.google.gwt.user.client.ui.TextBox; +import com.google.gwt.user.client.ui.Widget; +import gwt.react.client.api.React; +import gwt.react.client.api.ReactDOM; +import gwt.react.client.events.MouseEventHandler; +import gwt.react.client.events.MouseEvent; + +/** + * Entry point classes define onModuleLoad(). + */ +public class GWTReactApp implements EntryPoint { + /** + * The message displayed to the user when the server cannot be reached or + * returns an error. + */ + private static final String SERVER_ERROR = "An error occurred while " + + "attempting to contact the server. Please check your network " + "connection and try again."; + + + /** + * Inject gwt-react library script + */ + /*public interface JsClientBundle extends ClientBundle { + final JsClientBundle INSTANCE = GWT.create(JsClientBundle.class); + + @Source("resources/gwt-react-bundle.min.js") + TextResource gwtreactbundlejs(); + @Source("resources/gwt-react-router-bundle.min.js") + TextResource gwtreactrouterbundlejs(); + } + */ + + /** + * Create a remote service proxy to talk to the server-side Login service. + */ + private final LoginServiceAsync loginService = GWT.create(LoginService.class); + + final TextBox userNameField = new TextBox(); + final TextBox passwordField = new PasswordTextBox(); + final Button loginButton = new Button("LOGIN"); + final Button goToReactButton = new Button("GO TO REACT APP"); + final Label loggedUserInfo = new Label(); + + private void setLoginFormVisibility(boolean displayLoginForm){ + RootPanel.get("loginFormDiv").setVisible(displayLoginForm); + RootPanel.get("loggedInDiv").setVisible(!displayLoginForm); + } + + private void setReactComponentVisibility(boolean displayReactComponent){ + RootPanel.get("gwtAppDiv").setVisible(!displayReactComponent); + RootPanel.get("reactAppDiv").setVisible(displayReactComponent); + } + + private void setLoggedInUserInfo(String username){ + loggedUserInfo.setText("Current logged in user: " + username); + } + + private void displayLoginWindow(boolean displayLogin){ + // Hide info and React button + if(displayLogin) + loggedUserInfo.setText(""); + + goToReactButton.setVisible(!displayLogin); + RootPanel.get("userNameFieldLabel").setVisible(displayLogin); + RootPanel.get("passwordFieldLabel").setVisible(displayLogin); + userNameField.setVisible(displayLogin); + passwordField.setVisible(displayLogin); + loginButton.setVisible(displayLogin); + } + + private void checkWithServerIfSessionIdIsStillLegal(String sessionID, boolean goToReactApp) + { + loginService.loginFromSessionServer(new AsyncCallback() + { + @Override + public void onFailure(Throwable caught) + { + setLoginFormVisibility(true); + Window.alert(SERVER_ERROR); + } + + @Override + public void onSuccess(UserDTO result) + { + if (result == null) + { + setLoginFormVisibility(true); + } else + { + if (result.getLoggedIn()) + { + if(!goToReactApp){ + setLoginFormVisibility(false); + setLoggedInUserInfo(result.getUserName()); + } + else{ + setReactComponentVisibility(true); + EmbeddedReact.ReactComponentProps componentProps = new EmbeddedReact.ReactComponentProps(); + + componentProps.onGoToGWTAppClicked = new MouseEventHandler() { + + @Override + public void onMouseEvent(MouseEvent event) { + setReactComponentVisibility(false); + String sessionID = Cookies.getCookie("sid"); + if (sessionID == null) + setLoginFormVisibility(true); + else + checkWithServerIfSessionIdIsStillLegal(sessionID, false); + + } + }; + componentProps.currentLoggedUser = result.getUserName(); + ReactDOM.render(React.createElement(EmbeddedReact::loggedInComponent, componentProps), Document.get().getElementById("reactAppDiv")); + } + + } else + { + displayLoginWindow(true); + } + } + } + + }); + + } + + /** + * This is the entry point method. + */ + @Override + public void onModuleLoad() { + RootPanel.get("userNameFieldContainer").add(userNameField); + RootPanel.get("passwordFieldContainer").add(passwordField); + RootPanel.get("loginButtonContainer").add(loginButton); + RootPanel.get("loggedInUserInfoContainer").add(loggedUserInfo); + RootPanel.get("goToReactApplicationButtonContainer").add(goToReactButton); + + // Focus the cursor on the name field when the app loads + userNameField.setFocus(true); + userNameField.selectAll(); + + String sessionID = Cookies.getCookie("sid"); + if (sessionID == null) + setLoginFormVisibility(true); + else + checkWithServerIfSessionIdIsStillLegal(sessionID, false); + + // Create a handler for the sendButton and nameField + class MyHandler implements ClickHandler, KeyUpHandler { + /** + * Fired when the user clicks on the sendButton. + */ + public void onClick(ClickEvent event) { + Widget sender = (Widget) event.getSource(); + if (sender == loginButton) { + loginUser(); + } else if (sender == goToReactButton) { + String sessionID = Cookies.getCookie("sid"); + if (sessionID == null) + setLoginFormVisibility(true); + else + checkWithServerIfSessionIdIsStillLegal(sessionID, true); + } + + } + + /** + * Fired when the user types in the nameField. + */ + public void onKeyUp(KeyUpEvent event) { + if (event.getNativeKeyCode() == KeyCodes.KEY_ENTER) { + loginUser(); + } + } + + private void loginUser(){ + + loginService.loginServer(userNameField.getValue(), passwordField.getValue(), new AsyncCallback() + { + @Override + public void onSuccess(UserDTO result) + { + + if (result.getLoggedIn()) + { + //Set session cookie for 60s + String sessionID = result.getSessionId(); + final long DURATION = 1000 * 10; + Date expires = new Date(System.currentTimeMillis() + DURATION); + Cookies.setCookie("sid", sessionID, expires, null, "/", false); + setLoginFormVisibility(false); + setLoggedInUserInfo(result.getUserName()); + } else + { + Window.alert(SERVER_ERROR); + } + + } + + @Override + public void onFailure(Throwable caught) + { + + Window.alert(SERVER_ERROR); + } + }); + + } + } + + // Add a handler to send the name to the server + MyHandler handler = new MyHandler(); + loginButton.addClickHandler(handler); + passwordField.addKeyUpHandler(handler); + goToReactButton.addClickHandler(handler); + } +} diff --git a/GWTReactApp/src/com/gwt/app/client/LoginService.java b/GWTReactApp/src/com/gwt/app/client/LoginService.java new file mode 100644 index 0000000..91502b3 --- /dev/null +++ b/GWTReactApp/src/com/gwt/app/client/LoginService.java @@ -0,0 +1,14 @@ +package com.gwt.app.client; +import com.google.gwt.user.client.rpc.RemoteService; +import com.google.gwt.user.client.rpc.RemoteServiceRelativePath; +import com.gwt.app.shared.UserDTO; + +@RemoteServiceRelativePath("login") +public interface LoginService extends RemoteService +{ + UserDTO loginServer(String name, String password); + + UserDTO loginFromSessionServer(); + + void logout(); +} \ No newline at end of file diff --git a/GWTReactApp/src/com/gwt/app/client/LoginServiceAsync.java b/GWTReactApp/src/com/gwt/app/client/LoginServiceAsync.java new file mode 100644 index 0000000..6150b1c --- /dev/null +++ b/GWTReactApp/src/com/gwt/app/client/LoginServiceAsync.java @@ -0,0 +1,13 @@ +package com.gwt.app.client; + +import com.google.gwt.user.client.rpc.AsyncCallback; +import com.gwt.app.shared.UserDTO; + +public interface LoginServiceAsync +{ + void loginServer(String name, String password, AsyncCallback callback); + + void loginFromSessionServer(AsyncCallback callback); + + void logout(AsyncCallback callback); +} diff --git a/GWTReactApp/src/com/gwt/app/client/components/EmbeddedReact.java b/GWTReactApp/src/com/gwt/app/client/components/EmbeddedReact.java new file mode 100644 index 0000000..a62c1a8 --- /dev/null +++ b/GWTReactApp/src/com/gwt/app/client/components/EmbeddedReact.java @@ -0,0 +1,38 @@ +package com.gwt.app.client.components; +import static gwt.react.client.api.React.DOM.*; +import gwt.react.client.elements.DOMElement; +import gwt.react.client.events.MouseEventHandler; +import gwt.react.client.proptypes.BaseProps; +import gwt.react.client.proptypes.html.BtnProps; +import gwt.react.client.proptypes.html.HtmlProps; +import jsinterop.annotations.JsPackage; +import jsinterop.annotations.JsType; + +public class EmbeddedReact { + + @JsType(isNative = true, namespace = JsPackage.GLOBAL, name = "Object") + public + static class ReactComponentProps extends BaseProps { + // Add getters instead of public identifiers + public String currentLoggedUser; + public MouseEventHandler onGoToGWTAppClicked; + } + + public static DOMElement loggedInComponent(ReactComponentProps props) { + return div(null, + h1(null, "Test application - React"), + table(new HtmlProps().className("tableCenter"), + tr(new HtmlProps().className("largeTextField"), + div(null, "Current logged in user: " + props.currentLoggedUser)), + tr(new HtmlProps().className("tableCenterRow"), + button( + new BtnProps() + .className("gwt-Button") + .onClick(props.onGoToGWTAppClicked), + "GO TO GWT APP" + ) + ))); + + }; +} + diff --git a/GWTReactApp/src/com/gwt/app/server/.DS_Store b/GWTReactApp/src/com/gwt/app/server/.DS_Store new file mode 100644 index 0000000..37a9146 Binary files /dev/null and b/GWTReactApp/src/com/gwt/app/server/.DS_Store differ diff --git a/GWTReactApp/src/com/gwt/app/server/LoginServiceImpl.java b/GWTReactApp/src/com/gwt/app/server/LoginServiceImpl.java new file mode 100644 index 0000000..e77334b --- /dev/null +++ b/GWTReactApp/src/com/gwt/app/server/LoginServiceImpl.java @@ -0,0 +1,61 @@ +package com.gwt.app.server; +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpSession; +import com.google.gwt.user.server.rpc.RemoteServiceServlet; +import com.gwt.app.client.LoginService; +import com.gwt.app.shared.UserDTO; + +public class LoginServiceImpl extends RemoteServiceServlet implements LoginService +{ + private static final long serialVersionUID = 4456105400553118785L; + + @Override + public UserDTO loginServer(String name, String password) + { + UserDTO user = new UserDTO(name, password); + user.setLoggedIn(true); + storeUserInSession(user); + return user; + } + + @Override + public UserDTO loginFromSessionServer() + { + return getUserAlreadyFromSession(); + } + + @Override + public void logout() + { + deleteUserFromSession(); + } + + private UserDTO getUserAlreadyFromSession() + { + UserDTO user = null; + HttpServletRequest httpServletRequest = this.getThreadLocalRequest(); + HttpSession session = httpServletRequest.getSession(); + Object userObj = session.getAttribute("user"); + if (userObj != null && userObj instanceof UserDTO) + { + user = (UserDTO) userObj; + } + return user; + } + + private void storeUserInSession(UserDTO user) + { + HttpServletRequest httpServletRequest = this.getThreadLocalRequest(); + HttpSession session = httpServletRequest.getSession(true); + user.setSessionId(session.getId()); + session.setAttribute("user", user); + } + + private void deleteUserFromSession() + { + HttpServletRequest httpServletRequest = this.getThreadLocalRequest(); + HttpSession session = httpServletRequest.getSession(); + session.removeAttribute("user"); + } + +} \ No newline at end of file diff --git a/GWTReactApp/src/com/gwt/app/shared/UserDTO.java b/GWTReactApp/src/com/gwt/app/shared/UserDTO.java new file mode 100644 index 0000000..8262e68 --- /dev/null +++ b/GWTReactApp/src/com/gwt/app/shared/UserDTO.java @@ -0,0 +1,58 @@ +package com.gwt.app.shared; + +import java.io.Serializable; + +public class UserDTO implements Serializable +{ + private static final long serialVersionUID = 3196402615838002153L; + + private String userName; + + private String password; + + private boolean loggedIn; + + private String sessionId; + + public UserDTO() + { + } + + public UserDTO(String name, String password) + { + setUserName(name); + setPassword(password); + } + + public String getUserName() { + return userName; + } + + public void setUserName(String userName) { + this.userName = userName; + } + + public String getPassword() { + return password; + } + + public void setPassword(String password) { + this.password = password; + } + + public boolean getLoggedIn() { + return loggedIn; + } + + public void setLoggedIn(boolean loggedIn) { + this.loggedIn = loggedIn; + } + + public String getSessionId() { + return sessionId; + } + + public void setSessionId(String sessionId) { + this.sessionId = sessionId; + } +} diff --git a/GWTReactApp/test-classes/.DS_Store b/GWTReactApp/test-classes/.DS_Store new file mode 100644 index 0000000..ae547d9 Binary files /dev/null and b/GWTReactApp/test-classes/.DS_Store differ diff --git a/GWTReactApp/test-classes/com/.DS_Store b/GWTReactApp/test-classes/com/.DS_Store new file mode 100644 index 0000000..cf8464f Binary files /dev/null and b/GWTReactApp/test-classes/com/.DS_Store differ diff --git a/GWTReactApp/test-classes/com/gwt/.DS_Store b/GWTReactApp/test-classes/com/gwt/.DS_Store new file mode 100644 index 0000000..9ddcda9 Binary files /dev/null and b/GWTReactApp/test-classes/com/gwt/.DS_Store differ diff --git a/GWTReactApp/test/.DS_Store b/GWTReactApp/test/.DS_Store new file mode 100644 index 0000000..ae547d9 Binary files /dev/null and b/GWTReactApp/test/.DS_Store differ diff --git a/GWTReactApp/test/com/.DS_Store b/GWTReactApp/test/com/.DS_Store new file mode 100644 index 0000000..cf8464f Binary files /dev/null and b/GWTReactApp/test/com/.DS_Store differ diff --git a/GWTReactApp/test/com/gwt/.DS_Store b/GWTReactApp/test/com/gwt/.DS_Store new file mode 100644 index 0000000..9ddcda9 Binary files /dev/null and b/GWTReactApp/test/com/gwt/.DS_Store differ diff --git a/GWTReactApp/war/GWTReactApp.css b/GWTReactApp/war/GWTReactApp.css new file mode 100644 index 0000000..995ba7b --- /dev/null +++ b/GWTReactApp/war/GWTReactApp.css @@ -0,0 +1,42 @@ +/** Add css rules here for your application. */ + + +/** Example rules used by the template application (remove for your app) */ +h1 { + font-size: 2em; + font-weight: bold; + color: #777777; + margin: 40px 0px 70px; + text-align: center; +} + +.sendButton { + display: block; + font-size: 16pt; +} + +/** Most GWT widgets already have a style name defined */ +.gwt-DialogBox { + width: 400px; +} + +.dialogVPanel { + margin: 5px; +} + +.tableCenter { + margin-left:auto; + margin-right:auto; + } + +.serverResponseLabelError { + color: red; +} + +.tableCenterRow{ + text-align:center; +} + +.largeTextField{ + font-size: large; +} diff --git a/GWTReactApp/war/GWTReactApp.html b/GWTReactApp/war/GWTReactApp.html new file mode 100644 index 0000000..093d415 --- /dev/null +++ b/GWTReactApp/war/GWTReactApp.html @@ -0,0 +1,84 @@ + + + + + + + + + + + + + + + + + + + Web Application Starter Project + + + + + + + + + + + + + + + + + + + +
+

Test application - GWT

+
+ + + + + + + + + + + + + + + + +
Username:
Password:
+
+ +
+ + + + + + + +
+
+
+ +
+
+ + + + + diff --git a/GWTReactApp/war/WEB-INF/classes/.DS_Store b/GWTReactApp/war/WEB-INF/classes/.DS_Store new file mode 100644 index 0000000..0f570b0 Binary files /dev/null and b/GWTReactApp/war/WEB-INF/classes/.DS_Store differ diff --git a/GWTReactApp/war/WEB-INF/classes/com/.DS_Store b/GWTReactApp/war/WEB-INF/classes/com/.DS_Store new file mode 100644 index 0000000..592f45a Binary files /dev/null and b/GWTReactApp/war/WEB-INF/classes/com/.DS_Store differ diff --git a/GWTReactApp/war/WEB-INF/classes/com/gwt/.DS_Store b/GWTReactApp/war/WEB-INF/classes/com/gwt/.DS_Store new file mode 100644 index 0000000..fe774d9 Binary files /dev/null and b/GWTReactApp/war/WEB-INF/classes/com/gwt/.DS_Store differ diff --git a/GWTReactApp/war/WEB-INF/classes/com/gwt/app/.DS_Store b/GWTReactApp/war/WEB-INF/classes/com/gwt/app/.DS_Store new file mode 100644 index 0000000..914bc3e Binary files /dev/null and b/GWTReactApp/war/WEB-INF/classes/com/gwt/app/.DS_Store differ diff --git a/GWTReactApp/war/WEB-INF/classes/com/gwt/app/GWTReactApp.gwt.xml b/GWTReactApp/war/WEB-INF/classes/com/gwt/app/GWTReactApp.gwt.xml new file mode 100644 index 0000000..7240119 --- /dev/null +++ b/GWTReactApp/war/WEB-INF/classes/com/gwt/app/GWTReactApp.gwt.xml @@ -0,0 +1,36 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/GWTReactApp/war/WEB-INF/classes/com/gwt/app/client/.DS_Store b/GWTReactApp/war/WEB-INF/classes/com/gwt/app/client/.DS_Store new file mode 100644 index 0000000..069587e Binary files /dev/null and b/GWTReactApp/war/WEB-INF/classes/com/gwt/app/client/.DS_Store differ diff --git a/GWTReactApp/war/WEB-INF/classes/com/gwt/app/server/.DS_Store b/GWTReactApp/war/WEB-INF/classes/com/gwt/app/server/.DS_Store new file mode 100644 index 0000000..37a9146 Binary files /dev/null and b/GWTReactApp/war/WEB-INF/classes/com/gwt/app/server/.DS_Store differ diff --git a/GWTReactApp/war/WEB-INF/web.xml b/GWTReactApp/war/WEB-INF/web.xml new file mode 100644 index 0000000..f44b788 --- /dev/null +++ b/GWTReactApp/war/WEB-INF/web.xml @@ -0,0 +1,24 @@ + + + + + + LoginServiceImpl + com.gwt.app.server.LoginServiceImpl + + + + LoginServiceImpl + /gwtreactapp/login + + + + + GWTReactApp.html + + + diff --git a/GWTReactApp/war/favicon.ico b/GWTReactApp/war/favicon.ico new file mode 100644 index 0000000..858a707 Binary files /dev/null and b/GWTReactApp/war/favicon.ico differ diff --git a/GWTReactApp/war/gwtreactapp/4D2D28286D544A635FD6EA37FA87D1FD.gwt.rpc b/GWTReactApp/war/gwtreactapp/4D2D28286D544A635FD6EA37FA87D1FD.gwt.rpc new file mode 100644 index 0000000..ee29959 --- /dev/null +++ b/GWTReactApp/war/gwtreactapp/4D2D28286D544A635FD6EA37FA87D1FD.gwt.rpc @@ -0,0 +1,11 @@ +@FinalFields, false +com.google.gwt.user.client.rpc.IncompatibleRemoteServiceException, true, true, true, true, com.google.gwt.user.client.rpc.IncompatibleRemoteServiceException/3936916533, 3936916533 +com.google.gwt.user.client.rpc.RpcTokenException, true, true, false, false, com.google.gwt.user.client.rpc.RpcTokenException/2345075298, 2345075298 +com.google.gwt.user.client.rpc.XsrfToken, false, false, true, true, com.google.gwt.user.client.rpc.XsrfToken/4254043109, 4254043109 +com.gwt.app.client.GreetingService, false, false, false, false, _, 1638119995 +java.lang.Exception, true, false, true, false, java.lang.Exception/1920171873, 1920171873 +java.lang.IllegalArgumentException, true, true, false, false, java.lang.IllegalArgumentException/1755012560, 1755012560 +java.lang.NumberFormatException, true, true, false, false, java.lang.NumberFormatException/3305228476, 3305228476 +java.lang.RuntimeException, true, false, true, false, java.lang.RuntimeException/515124647, 515124647 +java.lang.String, true, true, true, true, java.lang.String/2004016611, 2004016611 +java.lang.Throwable, true, false, true, false, java.lang.Throwable/2953622131, 2953622131 diff --git a/GWTReactApp/war/gwtreactapp/E96CACDEE2BBB286130B4C9D986F55D5.gwt.rpc b/GWTReactApp/war/gwtreactapp/E96CACDEE2BBB286130B4C9D986F55D5.gwt.rpc new file mode 100644 index 0000000..8d1c140 --- /dev/null +++ b/GWTReactApp/war/gwtreactapp/E96CACDEE2BBB286130B4C9D986F55D5.gwt.rpc @@ -0,0 +1,10 @@ +@FinalFields, false +com.google.gwt.user.client.rpc.IncompatibleRemoteServiceException, true, true, true, true, com.google.gwt.user.client.rpc.IncompatibleRemoteServiceException/3936916533, 3936916533 +com.google.gwt.user.client.rpc.RpcTokenException, true, true, false, false, com.google.gwt.user.client.rpc.RpcTokenException/2345075298, 2345075298 +com.google.gwt.user.client.rpc.XsrfToken, false, false, true, true, com.google.gwt.user.client.rpc.XsrfToken/4254043109, 4254043109 +com.gwt.app.client.LoginService, false, false, false, false, _, 2875975256 +com.gwt.app.shared.UserDTO, true, true, false, false, com.gwt.app.shared.UserDTO/3966925806, 3966925806 +java.lang.Exception, true, false, true, false, java.lang.Exception/1920171873, 1920171873 +java.lang.RuntimeException, true, false, true, false, java.lang.RuntimeException/515124647, 515124647 +java.lang.String, true, true, true, true, java.lang.String/2004016611, 2004016611 +java.lang.Throwable, true, false, true, false, java.lang.Throwable/2953622131, 2953622131 diff --git a/GWTReactApp/war/gwtreactapp/clear.cache.gif b/GWTReactApp/war/gwtreactapp/clear.cache.gif new file mode 100644 index 0000000..e565824 Binary files /dev/null and b/GWTReactApp/war/gwtreactapp/clear.cache.gif differ diff --git a/GWTReactApp/war/gwtreactapp/gwt-react-bundle.js b/GWTReactApp/war/gwtreactapp/gwt-react-bundle.js new file mode 100644 index 0000000..22ebb96 --- /dev/null +++ b/GWTReactApp/war/gwtreactapp/gwt-react-bundle.js @@ -0,0 +1,8225 @@ +!function(modules) { + function __webpack_require__(moduleId) { + if (installedModules[moduleId]) return installedModules[moduleId].exports; + var module = installedModules[moduleId] = { + exports: {}, + id: moduleId, + loaded: !1 + }; + return modules[moduleId].call(module.exports, module, module.exports, __webpack_require__), + module.loaded = !0, module.exports; + } + var installedModules = {}; + return __webpack_require__.m = modules, __webpack_require__.c = installedModules, + __webpack_require__.p = "", __webpack_require__(0); +}([ function(module, exports, __webpack_require__) { + "use strict"; + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { + default: obj + }; + } + var _react = __webpack_require__(1), _react2 = _interopRequireDefault(_react), _reactDom = __webpack_require__(37), _reactDom2 = _interopRequireDefault(_reactDom), _universalCookie = __webpack_require__(184), _server = (_interopRequireDefault(_universalCookie), + __webpack_require__(188)), _server2 = _interopRequireDefault(_server); + window.React = _react2.default, window.ReactDOM = _reactDom2.default, window.ReactDOMServer = _server2.default; + var GWTReact = {}; + GWTReact.cast = function(obj) { + return obj; + }, window.GWTReact = GWTReact; +}, function(module, exports, __webpack_require__) { + "use strict"; + module.exports = __webpack_require__(2); +}, function(module, exports, __webpack_require__) { + (function(process) { + "use strict"; + var _assign = __webpack_require__(4), ReactBaseClasses = __webpack_require__(5), ReactChildren = __webpack_require__(14), ReactDOMFactories = __webpack_require__(22), ReactElement = __webpack_require__(16), ReactPropTypes = __webpack_require__(28), ReactVersion = __webpack_require__(33), createReactClass = __webpack_require__(34), onlyChild = __webpack_require__(36), createElement = ReactElement.createElement, createFactory = ReactElement.createFactory, cloneElement = ReactElement.cloneElement; + if ("production" !== process.env.NODE_ENV) { + var lowPriorityWarning = __webpack_require__(13), canDefineProperty = __webpack_require__(10), ReactElementValidator = __webpack_require__(23), didWarnPropTypesDeprecated = !1; + createElement = ReactElementValidator.createElement, createFactory = ReactElementValidator.createFactory, + cloneElement = ReactElementValidator.cloneElement; + } + var __spread = _assign, createMixin = function(mixin) { + return mixin; + }; + if ("production" !== process.env.NODE_ENV) { + var warnedForSpread = !1, warnedForCreateMixin = !1; + __spread = function() { + return lowPriorityWarning(warnedForSpread, "React.__spread is deprecated and should not be used. Use Object.assign directly or another helper function with similar semantics. You may be seeing this warning due to your compiler. See https://fb.me/react-spread-deprecation for more details."), + warnedForSpread = !0, _assign.apply(null, arguments); + }, createMixin = function(mixin) { + return lowPriorityWarning(warnedForCreateMixin, "React.createMixin is deprecated and should not be used. In React v16.0, it will be removed. You can use this mixin directly instead. See https://fb.me/createmixin-was-never-implemented for more info."), + warnedForCreateMixin = !0, mixin; + }; + } + var React = { + Children: { + map: ReactChildren.map, + forEach: ReactChildren.forEach, + count: ReactChildren.count, + toArray: ReactChildren.toArray, + only: onlyChild + }, + Component: ReactBaseClasses.Component, + PureComponent: ReactBaseClasses.PureComponent, + createElement: createElement, + cloneElement: cloneElement, + isValidElement: ReactElement.isValidElement, + PropTypes: ReactPropTypes, + createClass: createReactClass, + createFactory: createFactory, + createMixin: createMixin, + DOM: ReactDOMFactories, + version: ReactVersion, + __spread: __spread + }; + if ("production" !== process.env.NODE_ENV) { + var warnedForCreateClass = !1; + canDefineProperty && (Object.defineProperty(React, "PropTypes", { + get: function() { + return lowPriorityWarning(didWarnPropTypesDeprecated, "Accessing PropTypes via the main React package is deprecated, and will be removed in React v16.0. Use the latest available v15.* prop-types package from npm instead. For info on usage, compatibility, migration and more, see https://fb.me/prop-types-docs"), + didWarnPropTypesDeprecated = !0, ReactPropTypes; + } + }), Object.defineProperty(React, "createClass", { + get: function() { + return lowPriorityWarning(warnedForCreateClass, "Accessing createClass via the main React package is deprecated, and will be removed in React v16.0. Use a plain JavaScript class instead. If you're not yet ready to migrate, create-react-class v15.* is available on npm as a temporary, drop-in replacement. For more info see https://fb.me/react-create-class"), + warnedForCreateClass = !0, createReactClass; + } + })), React.DOM = {}; + var warnedForFactories = !1; + Object.keys(ReactDOMFactories).forEach(function(factory) { + React.DOM[factory] = function() { + return warnedForFactories || (lowPriorityWarning(!1, "Accessing factories like React.DOM.%s has been deprecated and will be removed in v16.0+. Use the react-dom-factories package instead. Version 1.0 provides a drop-in replacement. For more info, see https://fb.me/react-dom-factories", factory), + warnedForFactories = !0), ReactDOMFactories[factory].apply(ReactDOMFactories, arguments); + }; + }); + } + module.exports = React; + }).call(exports, __webpack_require__(3)); +}, function(module, exports) { + function defaultSetTimout() { + throw new Error("setTimeout has not been defined"); + } + function defaultClearTimeout() { + throw new Error("clearTimeout has not been defined"); + } + function runTimeout(fun) { + if (cachedSetTimeout === setTimeout) return setTimeout(fun, 0); + if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) return cachedSetTimeout = setTimeout, + setTimeout(fun, 0); + try { + return cachedSetTimeout(fun, 0); + } catch (e) { + try { + return cachedSetTimeout.call(null, fun, 0); + } catch (e) { + return cachedSetTimeout.call(this, fun, 0); + } + } + } + function runClearTimeout(marker) { + if (cachedClearTimeout === clearTimeout) return clearTimeout(marker); + if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) return cachedClearTimeout = clearTimeout, + clearTimeout(marker); + try { + return cachedClearTimeout(marker); + } catch (e) { + try { + return cachedClearTimeout.call(null, marker); + } catch (e) { + return cachedClearTimeout.call(this, marker); + } + } + } + function cleanUpNextTick() { + draining && currentQueue && (draining = !1, currentQueue.length ? queue = currentQueue.concat(queue) : queueIndex = -1, + queue.length && drainQueue()); + } + function drainQueue() { + if (!draining) { + var timeout = runTimeout(cleanUpNextTick); + draining = !0; + for (var len = queue.length; len; ) { + for (currentQueue = queue, queue = []; ++queueIndex < len; ) currentQueue && currentQueue[queueIndex].run(); + queueIndex = -1, len = queue.length; + } + currentQueue = null, draining = !1, runClearTimeout(timeout); + } + } + function Item(fun, array) { + this.fun = fun, this.array = array; + } + function noop() {} + var cachedSetTimeout, cachedClearTimeout, process = module.exports = {}; + !function() { + try { + cachedSetTimeout = "function" == typeof setTimeout ? setTimeout : defaultSetTimout; + } catch (e) { + cachedSetTimeout = defaultSetTimout; + } + try { + cachedClearTimeout = "function" == typeof clearTimeout ? clearTimeout : defaultClearTimeout; + } catch (e) { + cachedClearTimeout = defaultClearTimeout; + } + }(); + var currentQueue, queue = [], draining = !1, queueIndex = -1; + process.nextTick = function(fun) { + var args = new Array(arguments.length - 1); + if (arguments.length > 1) for (var i = 1; i < arguments.length; i++) args[i - 1] = arguments[i]; + queue.push(new Item(fun, args)), 1 !== queue.length || draining || runTimeout(drainQueue); + }, Item.prototype.run = function() { + this.fun.apply(null, this.array); + }, process.title = "browser", process.browser = !0, process.env = {}, process.argv = [], + process.version = "", process.versions = {}, process.on = noop, process.addListener = noop, + process.once = noop, process.off = noop, process.removeListener = noop, process.removeAllListeners = noop, + process.emit = noop, process.prependListener = noop, process.prependOnceListener = noop, + process.listeners = function(name) { + return []; + }, process.binding = function(name) { + throw new Error("process.binding is not supported"); + }, process.cwd = function() { + return "/"; + }, process.chdir = function(dir) { + throw new Error("process.chdir is not supported"); + }, process.umask = function() { + return 0; + }; +}, function(module, exports) { + "use strict"; + function toObject(val) { + if (null === val || void 0 === val) throw new TypeError("Object.assign cannot be called with null or undefined"); + return Object(val); + } + function shouldUseNative() { + try { + if (!Object.assign) return !1; + var test1 = new String("abc"); + if (test1[5] = "de", "5" === Object.getOwnPropertyNames(test1)[0]) return !1; + for (var test2 = {}, i = 0; i < 10; i++) test2["_" + String.fromCharCode(i)] = i; + var order2 = Object.getOwnPropertyNames(test2).map(function(n) { + return test2[n]; + }); + if ("0123456789" !== order2.join("")) return !1; + var test3 = {}; + return "abcdefghijklmnopqrst".split("").forEach(function(letter) { + test3[letter] = letter; + }), "abcdefghijklmnopqrst" === Object.keys(Object.assign({}, test3)).join(""); + } catch (err) { + return !1; + } + } + var getOwnPropertySymbols = Object.getOwnPropertySymbols, hasOwnProperty = Object.prototype.hasOwnProperty, propIsEnumerable = Object.prototype.propertyIsEnumerable; + module.exports = shouldUseNative() ? Object.assign : function(target, source) { + for (var from, symbols, to = toObject(target), s = 1; s < arguments.length; s++) { + from = Object(arguments[s]); + for (var key in from) hasOwnProperty.call(from, key) && (to[key] = from[key]); + if (getOwnPropertySymbols) { + symbols = getOwnPropertySymbols(from); + for (var i = 0; i < symbols.length; i++) propIsEnumerable.call(from, symbols[i]) && (to[symbols[i]] = from[symbols[i]]); + } + } + return to; + }; +}, function(module, exports, __webpack_require__) { + (function(process) { + "use strict"; + function ReactComponent(props, context, updater) { + this.props = props, this.context = context, this.refs = emptyObject, this.updater = updater || ReactNoopUpdateQueue; + } + function ReactPureComponent(props, context, updater) { + this.props = props, this.context = context, this.refs = emptyObject, this.updater = updater || ReactNoopUpdateQueue; + } + function ComponentDummy() {} + var _prodInvariant = __webpack_require__(6), _assign = __webpack_require__(4), ReactNoopUpdateQueue = __webpack_require__(7), canDefineProperty = __webpack_require__(10), emptyObject = __webpack_require__(11), invariant = __webpack_require__(12), lowPriorityWarning = __webpack_require__(13); + if (ReactComponent.prototype.isReactComponent = {}, ReactComponent.prototype.setState = function(partialState, callback) { + "object" != typeof partialState && "function" != typeof partialState && null != partialState ? "production" !== process.env.NODE_ENV ? invariant(!1, "setState(...): takes an object of state variables to update or a function which returns an object of state variables.") : _prodInvariant("85") : void 0, + this.updater.enqueueSetState(this, partialState), callback && this.updater.enqueueCallback(this, callback, "setState"); + }, ReactComponent.prototype.forceUpdate = function(callback) { + this.updater.enqueueForceUpdate(this), callback && this.updater.enqueueCallback(this, callback, "forceUpdate"); + }, "production" !== process.env.NODE_ENV) { + var deprecatedAPIs = { + isMounted: [ "isMounted", "Instead, make sure to clean up subscriptions and pending requests in componentWillUnmount to prevent memory leaks." ], + replaceState: [ "replaceState", "Refactor your code to use setState instead (see https://github.com/facebook/react/issues/3236)." ] + }, defineDeprecationWarning = function(methodName, info) { + canDefineProperty && Object.defineProperty(ReactComponent.prototype, methodName, { + get: function() { + lowPriorityWarning(!1, "%s(...) is deprecated in plain JavaScript React classes. %s", info[0], info[1]); + } + }); + }; + for (var fnName in deprecatedAPIs) deprecatedAPIs.hasOwnProperty(fnName) && defineDeprecationWarning(fnName, deprecatedAPIs[fnName]); + } + ComponentDummy.prototype = ReactComponent.prototype, ReactPureComponent.prototype = new ComponentDummy(), + ReactPureComponent.prototype.constructor = ReactPureComponent, _assign(ReactPureComponent.prototype, ReactComponent.prototype), + ReactPureComponent.prototype.isPureReactComponent = !0, module.exports = { + Component: ReactComponent, + PureComponent: ReactPureComponent + }; + }).call(exports, __webpack_require__(3)); +}, function(module, exports) { + "use strict"; + function reactProdInvariant(code) { + for (var argCount = arguments.length - 1, message = "Minified React error #" + code + "; visit http://facebook.github.io/react/docs/error-decoder.html?invariant=" + code, argIdx = 0; argIdx < argCount; argIdx++) message += "&args[]=" + encodeURIComponent(arguments[argIdx + 1]); + message += " for the full message or use the non-minified dev environment for full errors and additional helpful warnings."; + var error = new Error(message); + throw error.name = "Invariant Violation", error.framesToPop = 1, error; + } + module.exports = reactProdInvariant; +}, function(module, exports, __webpack_require__) { + (function(process) { + "use strict"; + function warnNoop(publicInstance, callerName) { + if ("production" !== process.env.NODE_ENV) { + var constructor = publicInstance.constructor; + "production" !== process.env.NODE_ENV ? warning(!1, "%s(...): Can only update a mounted or mounting component. This usually means you called %s() on an unmounted component. This is a no-op. Please check the code for the %s component.", callerName, callerName, constructor && (constructor.displayName || constructor.name) || "ReactClass") : void 0; + } + } + var warning = __webpack_require__(8), ReactNoopUpdateQueue = { + isMounted: function(publicInstance) { + return !1; + }, + enqueueCallback: function(publicInstance, callback) {}, + enqueueForceUpdate: function(publicInstance) { + warnNoop(publicInstance, "forceUpdate"); + }, + enqueueReplaceState: function(publicInstance, completeState) { + warnNoop(publicInstance, "replaceState"); + }, + enqueueSetState: function(publicInstance, partialState) { + warnNoop(publicInstance, "setState"); + } + }; + module.exports = ReactNoopUpdateQueue; + }).call(exports, __webpack_require__(3)); +}, function(module, exports, __webpack_require__) { + (function(process) { + "use strict"; + var emptyFunction = __webpack_require__(9), warning = emptyFunction; + "production" !== process.env.NODE_ENV && !function() { + var printWarning = function(format) { + for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) args[_key - 1] = arguments[_key]; + var argIndex = 0, message = "Warning: " + format.replace(/%s/g, function() { + return args[argIndex++]; + }); + "undefined" != typeof console && console.error(message); + try { + throw new Error(message); + } catch (x) {} + }; + warning = function(condition, format) { + if (void 0 === format) throw new Error("`warning(condition, format, ...args)` requires a warning message argument"); + if (0 !== format.indexOf("Failed Composite propType: ") && !condition) { + for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) args[_key2 - 2] = arguments[_key2]; + printWarning.apply(void 0, [ format ].concat(args)); + } + }; + }(), module.exports = warning; + }).call(exports, __webpack_require__(3)); +}, function(module, exports) { + "use strict"; + function makeEmptyFunction(arg) { + return function() { + return arg; + }; + } + var emptyFunction = function() {}; + emptyFunction.thatReturns = makeEmptyFunction, emptyFunction.thatReturnsFalse = makeEmptyFunction(!1), + emptyFunction.thatReturnsTrue = makeEmptyFunction(!0), emptyFunction.thatReturnsNull = makeEmptyFunction(null), + emptyFunction.thatReturnsThis = function() { + return this; + }, emptyFunction.thatReturnsArgument = function(arg) { + return arg; + }, module.exports = emptyFunction; +}, function(module, exports, __webpack_require__) { + (function(process) { + "use strict"; + var canDefineProperty = !1; + if ("production" !== process.env.NODE_ENV) try { + Object.defineProperty({}, "x", { + get: function() {} + }), canDefineProperty = !0; + } catch (x) {} + module.exports = canDefineProperty; + }).call(exports, __webpack_require__(3)); +}, function(module, exports, __webpack_require__) { + (function(process) { + "use strict"; + var emptyObject = {}; + "production" !== process.env.NODE_ENV && Object.freeze(emptyObject), module.exports = emptyObject; + }).call(exports, __webpack_require__(3)); +}, function(module, exports, __webpack_require__) { + (function(process) { + "use strict"; + function invariant(condition, format, a, b, c, d, e, f) { + if (validateFormat(format), !condition) { + var error; + if (void 0 === format) error = new Error("Minified exception occurred; use the non-minified dev environment for the full error message and additional helpful warnings."); else { + var args = [ a, b, c, d, e, f ], argIndex = 0; + error = new Error(format.replace(/%s/g, function() { + return args[argIndex++]; + })), error.name = "Invariant Violation"; + } + throw error.framesToPop = 1, error; + } + } + var validateFormat = function(format) {}; + "production" !== process.env.NODE_ENV && (validateFormat = function(format) { + if (void 0 === format) throw new Error("invariant requires an error message argument"); + }), module.exports = invariant; + }).call(exports, __webpack_require__(3)); +}, function(module, exports, __webpack_require__) { + (function(process) { + "use strict"; + var lowPriorityWarning = function() {}; + if ("production" !== process.env.NODE_ENV) { + var printWarning = function(format) { + for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) args[_key - 1] = arguments[_key]; + var argIndex = 0, message = "Warning: " + format.replace(/%s/g, function() { + return args[argIndex++]; + }); + "undefined" != typeof console && console.warn(message); + try { + throw new Error(message); + } catch (x) {} + }; + lowPriorityWarning = function(condition, format) { + if (void 0 === format) throw new Error("`warning(condition, format, ...args)` requires a warning message argument"); + if (!condition) { + for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) args[_key2 - 2] = arguments[_key2]; + printWarning.apply(void 0, [ format ].concat(args)); + } + }; + } + module.exports = lowPriorityWarning; + }).call(exports, __webpack_require__(3)); +}, function(module, exports, __webpack_require__) { + "use strict"; + function escapeUserProvidedKey(text) { + return ("" + text).replace(userProvidedKeyEscapeRegex, "$&/"); + } + function ForEachBookKeeping(forEachFunction, forEachContext) { + this.func = forEachFunction, this.context = forEachContext, this.count = 0; + } + function forEachSingleChild(bookKeeping, child, name) { + var func = bookKeeping.func, context = bookKeeping.context; + func.call(context, child, bookKeeping.count++); + } + function forEachChildren(children, forEachFunc, forEachContext) { + if (null == children) return children; + var traverseContext = ForEachBookKeeping.getPooled(forEachFunc, forEachContext); + traverseAllChildren(children, forEachSingleChild, traverseContext), ForEachBookKeeping.release(traverseContext); + } + function MapBookKeeping(mapResult, keyPrefix, mapFunction, mapContext) { + this.result = mapResult, this.keyPrefix = keyPrefix, this.func = mapFunction, this.context = mapContext, + this.count = 0; + } + function mapSingleChildIntoContext(bookKeeping, child, childKey) { + var result = bookKeeping.result, keyPrefix = bookKeeping.keyPrefix, func = bookKeeping.func, context = bookKeeping.context, mappedChild = func.call(context, child, bookKeeping.count++); + Array.isArray(mappedChild) ? mapIntoWithKeyPrefixInternal(mappedChild, result, childKey, emptyFunction.thatReturnsArgument) : null != mappedChild && (ReactElement.isValidElement(mappedChild) && (mappedChild = ReactElement.cloneAndReplaceKey(mappedChild, keyPrefix + (!mappedChild.key || child && child.key === mappedChild.key ? "" : escapeUserProvidedKey(mappedChild.key) + "/") + childKey)), + result.push(mappedChild)); + } + function mapIntoWithKeyPrefixInternal(children, array, prefix, func, context) { + var escapedPrefix = ""; + null != prefix && (escapedPrefix = escapeUserProvidedKey(prefix) + "/"); + var traverseContext = MapBookKeeping.getPooled(array, escapedPrefix, func, context); + traverseAllChildren(children, mapSingleChildIntoContext, traverseContext), MapBookKeeping.release(traverseContext); + } + function mapChildren(children, func, context) { + if (null == children) return children; + var result = []; + return mapIntoWithKeyPrefixInternal(children, result, null, func, context), result; + } + function forEachSingleChildDummy(traverseContext, child, name) { + return null; + } + function countChildren(children, context) { + return traverseAllChildren(children, forEachSingleChildDummy, null); + } + function toArray(children) { + var result = []; + return mapIntoWithKeyPrefixInternal(children, result, null, emptyFunction.thatReturnsArgument), + result; + } + var PooledClass = __webpack_require__(15), ReactElement = __webpack_require__(16), emptyFunction = __webpack_require__(9), traverseAllChildren = __webpack_require__(19), twoArgumentPooler = PooledClass.twoArgumentPooler, fourArgumentPooler = PooledClass.fourArgumentPooler, userProvidedKeyEscapeRegex = /\/+/g; + ForEachBookKeeping.prototype.destructor = function() { + this.func = null, this.context = null, this.count = 0; + }, PooledClass.addPoolingTo(ForEachBookKeeping, twoArgumentPooler), MapBookKeeping.prototype.destructor = function() { + this.result = null, this.keyPrefix = null, this.func = null, this.context = null, + this.count = 0; + }, PooledClass.addPoolingTo(MapBookKeeping, fourArgumentPooler); + var ReactChildren = { + forEach: forEachChildren, + map: mapChildren, + mapIntoWithKeyPrefixInternal: mapIntoWithKeyPrefixInternal, + count: countChildren, + toArray: toArray + }; + module.exports = ReactChildren; +}, function(module, exports, __webpack_require__) { + (function(process) { + "use strict"; + var _prodInvariant = __webpack_require__(6), invariant = __webpack_require__(12), oneArgumentPooler = function(copyFieldsFrom) { + var Klass = this; + if (Klass.instancePool.length) { + var instance = Klass.instancePool.pop(); + return Klass.call(instance, copyFieldsFrom), instance; + } + return new Klass(copyFieldsFrom); + }, twoArgumentPooler = function(a1, a2) { + var Klass = this; + if (Klass.instancePool.length) { + var instance = Klass.instancePool.pop(); + return Klass.call(instance, a1, a2), instance; + } + return new Klass(a1, a2); + }, threeArgumentPooler = function(a1, a2, a3) { + var Klass = this; + if (Klass.instancePool.length) { + var instance = Klass.instancePool.pop(); + return Klass.call(instance, a1, a2, a3), instance; + } + return new Klass(a1, a2, a3); + }, fourArgumentPooler = function(a1, a2, a3, a4) { + var Klass = this; + if (Klass.instancePool.length) { + var instance = Klass.instancePool.pop(); + return Klass.call(instance, a1, a2, a3, a4), instance; + } + return new Klass(a1, a2, a3, a4); + }, standardReleaser = function(instance) { + var Klass = this; + instance instanceof Klass ? void 0 : "production" !== process.env.NODE_ENV ? invariant(!1, "Trying to release an instance into a pool of a different type.") : _prodInvariant("25"), + instance.destructor(), Klass.instancePool.length < Klass.poolSize && Klass.instancePool.push(instance); + }, DEFAULT_POOL_SIZE = 10, DEFAULT_POOLER = oneArgumentPooler, addPoolingTo = function(CopyConstructor, pooler) { + var NewKlass = CopyConstructor; + return NewKlass.instancePool = [], NewKlass.getPooled = pooler || DEFAULT_POOLER, + NewKlass.poolSize || (NewKlass.poolSize = DEFAULT_POOL_SIZE), NewKlass.release = standardReleaser, + NewKlass; + }, PooledClass = { + addPoolingTo: addPoolingTo, + oneArgumentPooler: oneArgumentPooler, + twoArgumentPooler: twoArgumentPooler, + threeArgumentPooler: threeArgumentPooler, + fourArgumentPooler: fourArgumentPooler + }; + module.exports = PooledClass; + }).call(exports, __webpack_require__(3)); +}, function(module, exports, __webpack_require__) { + (function(process) { + "use strict"; + function hasValidRef(config) { + if ("production" !== process.env.NODE_ENV && hasOwnProperty.call(config, "ref")) { + var getter = Object.getOwnPropertyDescriptor(config, "ref").get; + if (getter && getter.isReactWarning) return !1; + } + return void 0 !== config.ref; + } + function hasValidKey(config) { + if ("production" !== process.env.NODE_ENV && hasOwnProperty.call(config, "key")) { + var getter = Object.getOwnPropertyDescriptor(config, "key").get; + if (getter && getter.isReactWarning) return !1; + } + return void 0 !== config.key; + } + function defineKeyPropWarningGetter(props, displayName) { + var warnAboutAccessingKey = function() { + specialPropKeyWarningShown || (specialPropKeyWarningShown = !0, "production" !== process.env.NODE_ENV ? warning(!1, "%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://fb.me/react-special-props)", displayName) : void 0); + }; + warnAboutAccessingKey.isReactWarning = !0, Object.defineProperty(props, "key", { + get: warnAboutAccessingKey, + configurable: !0 + }); + } + function defineRefPropWarningGetter(props, displayName) { + var warnAboutAccessingRef = function() { + specialPropRefWarningShown || (specialPropRefWarningShown = !0, "production" !== process.env.NODE_ENV ? warning(!1, "%s: `ref` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://fb.me/react-special-props)", displayName) : void 0); + }; + warnAboutAccessingRef.isReactWarning = !0, Object.defineProperty(props, "ref", { + get: warnAboutAccessingRef, + configurable: !0 + }); + } + var specialPropKeyWarningShown, specialPropRefWarningShown, _assign = __webpack_require__(4), ReactCurrentOwner = __webpack_require__(17), warning = __webpack_require__(8), canDefineProperty = __webpack_require__(10), hasOwnProperty = Object.prototype.hasOwnProperty, REACT_ELEMENT_TYPE = __webpack_require__(18), RESERVED_PROPS = { + key: !0, + ref: !0, + __self: !0, + __source: !0 + }, ReactElement = function(type, key, ref, self, source, owner, props) { + var element = { + $$typeof: REACT_ELEMENT_TYPE, + type: type, + key: key, + ref: ref, + props: props, + _owner: owner + }; + return "production" !== process.env.NODE_ENV && (element._store = {}, canDefineProperty ? (Object.defineProperty(element._store, "validated", { + configurable: !1, + enumerable: !1, + writable: !0, + value: !1 + }), Object.defineProperty(element, "_self", { + configurable: !1, + enumerable: !1, + writable: !1, + value: self + }), Object.defineProperty(element, "_source", { + configurable: !1, + enumerable: !1, + writable: !1, + value: source + })) : (element._store.validated = !1, element._self = self, element._source = source), + Object.freeze && (Object.freeze(element.props), Object.freeze(element))), element; + }; + ReactElement.createElement = function(type, config, children) { + var propName, props = {}, key = null, ref = null, self = null, source = null; + if (null != config) { + hasValidRef(config) && (ref = config.ref), hasValidKey(config) && (key = "" + config.key), + self = void 0 === config.__self ? null : config.__self, source = void 0 === config.__source ? null : config.__source; + for (propName in config) hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName) && (props[propName] = config[propName]); + } + var childrenLength = arguments.length - 2; + if (1 === childrenLength) props.children = children; else if (childrenLength > 1) { + for (var childArray = Array(childrenLength), i = 0; i < childrenLength; i++) childArray[i] = arguments[i + 2]; + "production" !== process.env.NODE_ENV && Object.freeze && Object.freeze(childArray), + props.children = childArray; + } + if (type && type.defaultProps) { + var defaultProps = type.defaultProps; + for (propName in defaultProps) void 0 === props[propName] && (props[propName] = defaultProps[propName]); + } + if ("production" !== process.env.NODE_ENV && (key || ref) && ("undefined" == typeof props.$$typeof || props.$$typeof !== REACT_ELEMENT_TYPE)) { + var displayName = "function" == typeof type ? type.displayName || type.name || "Unknown" : type; + key && defineKeyPropWarningGetter(props, displayName), ref && defineRefPropWarningGetter(props, displayName); + } + return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props); + }, ReactElement.createFactory = function(type) { + var factory = ReactElement.createElement.bind(null, type); + return factory.type = type, factory; + }, ReactElement.cloneAndReplaceKey = function(oldElement, newKey) { + var newElement = ReactElement(oldElement.type, newKey, oldElement.ref, oldElement._self, oldElement._source, oldElement._owner, oldElement.props); + return newElement; + }, ReactElement.cloneElement = function(element, config, children) { + var propName, props = _assign({}, element.props), key = element.key, ref = element.ref, self = element._self, source = element._source, owner = element._owner; + if (null != config) { + hasValidRef(config) && (ref = config.ref, owner = ReactCurrentOwner.current), hasValidKey(config) && (key = "" + config.key); + var defaultProps; + element.type && element.type.defaultProps && (defaultProps = element.type.defaultProps); + for (propName in config) hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName) && (void 0 === config[propName] && void 0 !== defaultProps ? props[propName] = defaultProps[propName] : props[propName] = config[propName]); + } + var childrenLength = arguments.length - 2; + if (1 === childrenLength) props.children = children; else if (childrenLength > 1) { + for (var childArray = Array(childrenLength), i = 0; i < childrenLength; i++) childArray[i] = arguments[i + 2]; + props.children = childArray; + } + return ReactElement(element.type, key, ref, self, source, owner, props); + }, ReactElement.isValidElement = function(object) { + return "object" == typeof object && null !== object && object.$$typeof === REACT_ELEMENT_TYPE; + }, module.exports = ReactElement; + }).call(exports, __webpack_require__(3)); +}, function(module, exports) { + "use strict"; + var ReactCurrentOwner = { + current: null + }; + module.exports = ReactCurrentOwner; +}, function(module, exports) { + "use strict"; + var REACT_ELEMENT_TYPE = "function" == typeof Symbol && Symbol.for && Symbol.for("react.element") || 60103; + module.exports = REACT_ELEMENT_TYPE; +}, function(module, exports, __webpack_require__) { + (function(process) { + "use strict"; + function getComponentKey(component, index) { + return component && "object" == typeof component && null != component.key ? KeyEscapeUtils.escape(component.key) : index.toString(36); + } + function traverseAllChildrenImpl(children, nameSoFar, callback, traverseContext) { + var type = typeof children; + if ("undefined" !== type && "boolean" !== type || (children = null), null === children || "string" === type || "number" === type || "object" === type && children.$$typeof === REACT_ELEMENT_TYPE) return callback(traverseContext, children, "" === nameSoFar ? SEPARATOR + getComponentKey(children, 0) : nameSoFar), + 1; + var child, nextName, subtreeCount = 0, nextNamePrefix = "" === nameSoFar ? SEPARATOR : nameSoFar + SUBSEPARATOR; + if (Array.isArray(children)) for (var i = 0; i < children.length; i++) child = children[i], + nextName = nextNamePrefix + getComponentKey(child, i), subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext); else { + var iteratorFn = getIteratorFn(children); + if (iteratorFn) { + var step, iterator = iteratorFn.call(children); + if (iteratorFn !== children.entries) for (var ii = 0; !(step = iterator.next()).done; ) child = step.value, + nextName = nextNamePrefix + getComponentKey(child, ii++), subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext); else { + if ("production" !== process.env.NODE_ENV) { + var mapsAsChildrenAddendum = ""; + if (ReactCurrentOwner.current) { + var mapsAsChildrenOwnerName = ReactCurrentOwner.current.getName(); + mapsAsChildrenOwnerName && (mapsAsChildrenAddendum = " Check the render method of `" + mapsAsChildrenOwnerName + "`."); + } + "production" !== process.env.NODE_ENV ? warning(didWarnAboutMaps, "Using Maps as children is not yet fully supported. It is an experimental feature that might be removed. Convert it to a sequence / iterable of keyed ReactElements instead.%s", mapsAsChildrenAddendum) : void 0, + didWarnAboutMaps = !0; + } + for (;!(step = iterator.next()).done; ) { + var entry = step.value; + entry && (child = entry[1], nextName = nextNamePrefix + KeyEscapeUtils.escape(entry[0]) + SUBSEPARATOR + getComponentKey(child, 0), + subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext)); + } + } + } else if ("object" === type) { + var addendum = ""; + if ("production" !== process.env.NODE_ENV && (addendum = " If you meant to render a collection of children, use an array instead or wrap the object using createFragment(object) from the React add-ons.", + children._isReactElement && (addendum = " It looks like you're using an element created by a different version of React. Make sure to use only one copy of React."), + ReactCurrentOwner.current)) { + var name = ReactCurrentOwner.current.getName(); + name && (addendum += " Check the render method of `" + name + "`."); + } + var childrenString = String(children); + "production" !== process.env.NODE_ENV ? invariant(!1, "Objects are not valid as a React child (found: %s).%s", "[object Object]" === childrenString ? "object with keys {" + Object.keys(children).join(", ") + "}" : childrenString, addendum) : _prodInvariant("31", "[object Object]" === childrenString ? "object with keys {" + Object.keys(children).join(", ") + "}" : childrenString, addendum); + } + } + return subtreeCount; + } + function traverseAllChildren(children, callback, traverseContext) { + return null == children ? 0 : traverseAllChildrenImpl(children, "", callback, traverseContext); + } + var _prodInvariant = __webpack_require__(6), ReactCurrentOwner = __webpack_require__(17), REACT_ELEMENT_TYPE = __webpack_require__(18), getIteratorFn = __webpack_require__(20), invariant = __webpack_require__(12), KeyEscapeUtils = __webpack_require__(21), warning = __webpack_require__(8), SEPARATOR = ".", SUBSEPARATOR = ":", didWarnAboutMaps = !1; + module.exports = traverseAllChildren; + }).call(exports, __webpack_require__(3)); +}, function(module, exports) { + "use strict"; + function getIteratorFn(maybeIterable) { + var iteratorFn = maybeIterable && (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]); + if ("function" == typeof iteratorFn) return iteratorFn; + } + var ITERATOR_SYMBOL = "function" == typeof Symbol && Symbol.iterator, FAUX_ITERATOR_SYMBOL = "@@iterator"; + module.exports = getIteratorFn; +}, function(module, exports) { + "use strict"; + function escape(key) { + var escapeRegex = /[=:]/g, escaperLookup = { + "=": "=0", + ":": "=2" + }, escapedString = ("" + key).replace(escapeRegex, function(match) { + return escaperLookup[match]; + }); + return "$" + escapedString; + } + function unescape(key) { + var unescapeRegex = /(=0|=2)/g, unescaperLookup = { + "=0": "=", + "=2": ":" + }, keySubstring = "." === key[0] && "$" === key[1] ? key.substring(2) : key.substring(1); + return ("" + keySubstring).replace(unescapeRegex, function(match) { + return unescaperLookup[match]; + }); + } + var KeyEscapeUtils = { + escape: escape, + unescape: unescape + }; + module.exports = KeyEscapeUtils; +}, function(module, exports, __webpack_require__) { + (function(process) { + "use strict"; + var ReactElement = __webpack_require__(16), createDOMFactory = ReactElement.createFactory; + if ("production" !== process.env.NODE_ENV) { + var ReactElementValidator = __webpack_require__(23); + createDOMFactory = ReactElementValidator.createFactory; + } + var ReactDOMFactories = { + a: createDOMFactory("a"), + abbr: createDOMFactory("abbr"), + address: createDOMFactory("address"), + area: createDOMFactory("area"), + article: createDOMFactory("article"), + aside: createDOMFactory("aside"), + audio: createDOMFactory("audio"), + b: createDOMFactory("b"), + base: createDOMFactory("base"), + bdi: createDOMFactory("bdi"), + bdo: createDOMFactory("bdo"), + big: createDOMFactory("big"), + blockquote: createDOMFactory("blockquote"), + body: createDOMFactory("body"), + br: createDOMFactory("br"), + button: createDOMFactory("button"), + canvas: createDOMFactory("canvas"), + caption: createDOMFactory("caption"), + cite: createDOMFactory("cite"), + code: createDOMFactory("code"), + col: createDOMFactory("col"), + colgroup: createDOMFactory("colgroup"), + data: createDOMFactory("data"), + datalist: createDOMFactory("datalist"), + dd: createDOMFactory("dd"), + del: createDOMFactory("del"), + details: createDOMFactory("details"), + dfn: createDOMFactory("dfn"), + dialog: createDOMFactory("dialog"), + div: createDOMFactory("div"), + dl: createDOMFactory("dl"), + dt: createDOMFactory("dt"), + em: createDOMFactory("em"), + embed: createDOMFactory("embed"), + fieldset: createDOMFactory("fieldset"), + figcaption: createDOMFactory("figcaption"), + figure: createDOMFactory("figure"), + footer: createDOMFactory("footer"), + form: createDOMFactory("form"), + h1: createDOMFactory("h1"), + h2: createDOMFactory("h2"), + h3: createDOMFactory("h3"), + h4: createDOMFactory("h4"), + h5: createDOMFactory("h5"), + h6: createDOMFactory("h6"), + head: createDOMFactory("head"), + header: createDOMFactory("header"), + hgroup: createDOMFactory("hgroup"), + hr: createDOMFactory("hr"), + html: createDOMFactory("html"), + i: createDOMFactory("i"), + iframe: createDOMFactory("iframe"), + img: createDOMFactory("img"), + input: createDOMFactory("input"), + ins: createDOMFactory("ins"), + kbd: createDOMFactory("kbd"), + keygen: createDOMFactory("keygen"), + label: createDOMFactory("label"), + legend: createDOMFactory("legend"), + li: createDOMFactory("li"), + link: createDOMFactory("link"), + main: createDOMFactory("main"), + map: createDOMFactory("map"), + mark: createDOMFactory("mark"), + menu: createDOMFactory("menu"), + menuitem: createDOMFactory("menuitem"), + meta: createDOMFactory("meta"), + meter: createDOMFactory("meter"), + nav: createDOMFactory("nav"), + noscript: createDOMFactory("noscript"), + object: createDOMFactory("object"), + ol: createDOMFactory("ol"), + optgroup: createDOMFactory("optgroup"), + option: createDOMFactory("option"), + output: createDOMFactory("output"), + p: createDOMFactory("p"), + param: createDOMFactory("param"), + picture: createDOMFactory("picture"), + pre: createDOMFactory("pre"), + progress: createDOMFactory("progress"), + q: createDOMFactory("q"), + rp: createDOMFactory("rp"), + rt: createDOMFactory("rt"), + ruby: createDOMFactory("ruby"), + s: createDOMFactory("s"), + samp: createDOMFactory("samp"), + script: createDOMFactory("script"), + section: createDOMFactory("section"), + select: createDOMFactory("select"), + small: createDOMFactory("small"), + source: createDOMFactory("source"), + span: createDOMFactory("span"), + strong: createDOMFactory("strong"), + style: createDOMFactory("style"), + sub: createDOMFactory("sub"), + summary: createDOMFactory("summary"), + sup: createDOMFactory("sup"), + table: createDOMFactory("table"), + tbody: createDOMFactory("tbody"), + td: createDOMFactory("td"), + textarea: createDOMFactory("textarea"), + tfoot: createDOMFactory("tfoot"), + th: createDOMFactory("th"), + thead: createDOMFactory("thead"), + time: createDOMFactory("time"), + title: createDOMFactory("title"), + tr: createDOMFactory("tr"), + track: createDOMFactory("track"), + u: createDOMFactory("u"), + ul: createDOMFactory("ul"), + var: createDOMFactory("var"), + video: createDOMFactory("video"), + wbr: createDOMFactory("wbr"), + circle: createDOMFactory("circle"), + clipPath: createDOMFactory("clipPath"), + defs: createDOMFactory("defs"), + ellipse: createDOMFactory("ellipse"), + g: createDOMFactory("g"), + image: createDOMFactory("image"), + line: createDOMFactory("line"), + linearGradient: createDOMFactory("linearGradient"), + mask: createDOMFactory("mask"), + path: createDOMFactory("path"), + pattern: createDOMFactory("pattern"), + polygon: createDOMFactory("polygon"), + polyline: createDOMFactory("polyline"), + radialGradient: createDOMFactory("radialGradient"), + rect: createDOMFactory("rect"), + stop: createDOMFactory("stop"), + svg: createDOMFactory("svg"), + text: createDOMFactory("text"), + tspan: createDOMFactory("tspan") + }; + module.exports = ReactDOMFactories; + }).call(exports, __webpack_require__(3)); +}, function(module, exports, __webpack_require__) { + (function(process) { + "use strict"; + function getDeclarationErrorAddendum() { + if (ReactCurrentOwner.current) { + var name = ReactCurrentOwner.current.getName(); + if (name) return " Check the render method of `" + name + "`."; + } + return ""; + } + function getSourceInfoErrorAddendum(elementProps) { + if (null !== elementProps && void 0 !== elementProps && void 0 !== elementProps.__source) { + var source = elementProps.__source, fileName = source.fileName.replace(/^.*[\\\/]/, ""), lineNumber = source.lineNumber; + return " Check your code at " + fileName + ":" + lineNumber + "."; + } + return ""; + } + function getCurrentComponentErrorInfo(parentType) { + var info = getDeclarationErrorAddendum(); + if (!info) { + var parentName = "string" == typeof parentType ? parentType : parentType.displayName || parentType.name; + parentName && (info = " Check the top-level render call using <" + parentName + ">."); + } + return info; + } + function validateExplicitKey(element, parentType) { + if (element._store && !element._store.validated && null == element.key) { + element._store.validated = !0; + var memoizer = ownerHasKeyUseWarning.uniqueKey || (ownerHasKeyUseWarning.uniqueKey = {}), currentComponentErrorInfo = getCurrentComponentErrorInfo(parentType); + if (!memoizer[currentComponentErrorInfo]) { + memoizer[currentComponentErrorInfo] = !0; + var childOwner = ""; + element && element._owner && element._owner !== ReactCurrentOwner.current && (childOwner = " It was passed a child from " + element._owner.getName() + "."), + "production" !== process.env.NODE_ENV ? warning(!1, 'Each child in an array or iterator should have a unique "key" prop.%s%s See https://fb.me/react-warning-keys for more information.%s', currentComponentErrorInfo, childOwner, ReactComponentTreeHook.getCurrentStackAddendum(element)) : void 0; + } + } + } + function validateChildKeys(node, parentType) { + if ("object" == typeof node) if (Array.isArray(node)) for (var i = 0; i < node.length; i++) { + var child = node[i]; + ReactElement.isValidElement(child) && validateExplicitKey(child, parentType); + } else if (ReactElement.isValidElement(node)) node._store && (node._store.validated = !0); else if (node) { + var iteratorFn = getIteratorFn(node); + if (iteratorFn && iteratorFn !== node.entries) for (var step, iterator = iteratorFn.call(node); !(step = iterator.next()).done; ) ReactElement.isValidElement(step.value) && validateExplicitKey(step.value, parentType); + } + } + function validatePropTypes(element) { + var componentClass = element.type; + if ("function" == typeof componentClass) { + var name = componentClass.displayName || componentClass.name; + componentClass.propTypes && checkReactTypeSpec(componentClass.propTypes, element.props, "prop", name, element, null), + "function" == typeof componentClass.getDefaultProps && ("production" !== process.env.NODE_ENV ? warning(componentClass.getDefaultProps.isReactClassApproved, "getDefaultProps is only used on classic React.createClass definitions. Use a static property named `defaultProps` instead.") : void 0); + } + } + var ReactCurrentOwner = __webpack_require__(17), ReactComponentTreeHook = __webpack_require__(24), ReactElement = __webpack_require__(16), checkReactTypeSpec = __webpack_require__(25), canDefineProperty = __webpack_require__(10), getIteratorFn = __webpack_require__(20), warning = __webpack_require__(8), lowPriorityWarning = __webpack_require__(13), ownerHasKeyUseWarning = {}, ReactElementValidator = { + createElement: function(type, props, children) { + var validType = "string" == typeof type || "function" == typeof type; + if (!validType && "function" != typeof type && "string" != typeof type) { + var info = ""; + (void 0 === type || "object" == typeof type && null !== type && 0 === Object.keys(type).length) && (info += " You likely forgot to export your component from the file it's defined in."); + var sourceInfo = getSourceInfoErrorAddendum(props); + info += sourceInfo ? sourceInfo : getDeclarationErrorAddendum(), info += ReactComponentTreeHook.getCurrentStackAddendum(); + var currentSource = null !== props && void 0 !== props && void 0 !== props.__source ? props.__source : null; + ReactComponentTreeHook.pushNonStandardWarningStack(!0, currentSource), "production" !== process.env.NODE_ENV ? warning(!1, "React.createElement: type is invalid -- expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s", null == type ? type : typeof type, info) : void 0, + ReactComponentTreeHook.popNonStandardWarningStack(); + } + var element = ReactElement.createElement.apply(this, arguments); + if (null == element) return element; + if (validType) for (var i = 2; i < arguments.length; i++) validateChildKeys(arguments[i], type); + return validatePropTypes(element), element; + }, + createFactory: function(type) { + var validatedFactory = ReactElementValidator.createElement.bind(null, type); + return validatedFactory.type = type, "production" !== process.env.NODE_ENV && canDefineProperty && Object.defineProperty(validatedFactory, "type", { + enumerable: !1, + get: function() { + return lowPriorityWarning(!1, "Factory.type is deprecated. Access the class directly before passing it to createFactory."), + Object.defineProperty(this, "type", { + value: type + }), type; + } + }), validatedFactory; + }, + cloneElement: function(element, props, children) { + for (var newElement = ReactElement.cloneElement.apply(this, arguments), i = 2; i < arguments.length; i++) validateChildKeys(arguments[i], newElement.type); + return validatePropTypes(newElement), newElement; + } + }; + module.exports = ReactElementValidator; + }).call(exports, __webpack_require__(3)); +}, function(module, exports, __webpack_require__) { + (function(process) { + "use strict"; + function isNative(fn) { + var funcToString = Function.prototype.toString, hasOwnProperty = Object.prototype.hasOwnProperty, reIsNative = RegExp("^" + funcToString.call(hasOwnProperty).replace(/[\\^$.*+?()[\]{}|]/g, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"); + try { + var source = funcToString.call(fn); + return reIsNative.test(source); + } catch (err) { + return !1; + } + } + function purgeDeep(id) { + var item = getItem(id); + if (item) { + var childIDs = item.childIDs; + removeItem(id), childIDs.forEach(purgeDeep); + } + } + function describeComponentFrame(name, source, ownerName) { + return "\n in " + (name || "Unknown") + (source ? " (at " + source.fileName.replace(/^.*[\\\/]/, "") + ":" + source.lineNumber + ")" : ownerName ? " (created by " + ownerName + ")" : ""); + } + function getDisplayName(element) { + return null == element ? "#empty" : "string" == typeof element || "number" == typeof element ? "#text" : "string" == typeof element.type ? element.type : element.type.displayName || element.type.name || "Unknown"; + } + function describeID(id) { + var ownerName, name = ReactComponentTreeHook.getDisplayName(id), element = ReactComponentTreeHook.getElement(id), ownerID = ReactComponentTreeHook.getOwnerID(id); + return ownerID && (ownerName = ReactComponentTreeHook.getDisplayName(ownerID)), + "production" !== process.env.NODE_ENV ? warning(element, "ReactComponentTreeHook: Missing React element for debugID %s when building stack", id) : void 0, + describeComponentFrame(name, element && element._source, ownerName); + } + var setItem, getItem, removeItem, getItemIDs, addRoot, removeRoot, getRootIDs, _prodInvariant = __webpack_require__(6), ReactCurrentOwner = __webpack_require__(17), invariant = __webpack_require__(12), warning = __webpack_require__(8), canUseCollections = "function" == typeof Array.from && "function" == typeof Map && isNative(Map) && null != Map.prototype && "function" == typeof Map.prototype.keys && isNative(Map.prototype.keys) && "function" == typeof Set && isNative(Set) && null != Set.prototype && "function" == typeof Set.prototype.keys && isNative(Set.prototype.keys); + if (canUseCollections) { + var itemMap = new Map(), rootIDSet = new Set(); + setItem = function(id, item) { + itemMap.set(id, item); + }, getItem = function(id) { + return itemMap.get(id); + }, removeItem = function(id) { + itemMap.delete(id); + }, getItemIDs = function() { + return Array.from(itemMap.keys()); + }, addRoot = function(id) { + rootIDSet.add(id); + }, removeRoot = function(id) { + rootIDSet.delete(id); + }, getRootIDs = function() { + return Array.from(rootIDSet.keys()); + }; + } else { + var itemByKey = {}, rootByKey = {}, getKeyFromID = function(id) { + return "." + id; + }, getIDFromKey = function(key) { + return parseInt(key.substr(1), 10); + }; + setItem = function(id, item) { + var key = getKeyFromID(id); + itemByKey[key] = item; + }, getItem = function(id) { + var key = getKeyFromID(id); + return itemByKey[key]; + }, removeItem = function(id) { + var key = getKeyFromID(id); + delete itemByKey[key]; + }, getItemIDs = function() { + return Object.keys(itemByKey).map(getIDFromKey); + }, addRoot = function(id) { + var key = getKeyFromID(id); + rootByKey[key] = !0; + }, removeRoot = function(id) { + var key = getKeyFromID(id); + delete rootByKey[key]; + }, getRootIDs = function() { + return Object.keys(rootByKey).map(getIDFromKey); + }; + } + var unmountedIDs = [], ReactComponentTreeHook = { + onSetChildren: function(id, nextChildIDs) { + var item = getItem(id); + item ? void 0 : "production" !== process.env.NODE_ENV ? invariant(!1, "Item must have been set") : _prodInvariant("144"), + item.childIDs = nextChildIDs; + for (var i = 0; i < nextChildIDs.length; i++) { + var nextChildID = nextChildIDs[i], nextChild = getItem(nextChildID); + nextChild ? void 0 : "production" !== process.env.NODE_ENV ? invariant(!1, "Expected hook events to fire for the child before its parent includes it in onSetChildren().") : _prodInvariant("140"), + null == nextChild.childIDs && "object" == typeof nextChild.element && null != nextChild.element ? "production" !== process.env.NODE_ENV ? invariant(!1, "Expected onSetChildren() to fire for a container child before its parent includes it in onSetChildren().") : _prodInvariant("141") : void 0, + nextChild.isMounted ? void 0 : "production" !== process.env.NODE_ENV ? invariant(!1, "Expected onMountComponent() to fire for the child before its parent includes it in onSetChildren().") : _prodInvariant("71"), + null == nextChild.parentID && (nextChild.parentID = id), nextChild.parentID !== id ? "production" !== process.env.NODE_ENV ? invariant(!1, "Expected onBeforeMountComponent() parent and onSetChildren() to be consistent (%s has parents %s and %s).", nextChildID, nextChild.parentID, id) : _prodInvariant("142", nextChildID, nextChild.parentID, id) : void 0; + } + }, + onBeforeMountComponent: function(id, element, parentID) { + var item = { + element: element, + parentID: parentID, + text: null, + childIDs: [], + isMounted: !1, + updateCount: 0 + }; + setItem(id, item); + }, + onBeforeUpdateComponent: function(id, element) { + var item = getItem(id); + item && item.isMounted && (item.element = element); + }, + onMountComponent: function(id) { + var item = getItem(id); + item ? void 0 : "production" !== process.env.NODE_ENV ? invariant(!1, "Item must have been set") : _prodInvariant("144"), + item.isMounted = !0; + var isRoot = 0 === item.parentID; + isRoot && addRoot(id); + }, + onUpdateComponent: function(id) { + var item = getItem(id); + item && item.isMounted && item.updateCount++; + }, + onUnmountComponent: function(id) { + var item = getItem(id); + if (item) { + item.isMounted = !1; + var isRoot = 0 === item.parentID; + isRoot && removeRoot(id); + } + unmountedIDs.push(id); + }, + purgeUnmountedComponents: function() { + if (!ReactComponentTreeHook._preventPurging) { + for (var i = 0; i < unmountedIDs.length; i++) { + var id = unmountedIDs[i]; + purgeDeep(id); + } + unmountedIDs.length = 0; + } + }, + isMounted: function(id) { + var item = getItem(id); + return !!item && item.isMounted; + }, + getCurrentStackAddendum: function(topElement) { + var info = ""; + if (topElement) { + var name = getDisplayName(topElement), owner = topElement._owner; + info += describeComponentFrame(name, topElement._source, owner && owner.getName()); + } + var currentOwner = ReactCurrentOwner.current, id = currentOwner && currentOwner._debugID; + return info += ReactComponentTreeHook.getStackAddendumByID(id); + }, + getStackAddendumByID: function(id) { + for (var info = ""; id; ) info += describeID(id), id = ReactComponentTreeHook.getParentID(id); + return info; + }, + getChildIDs: function(id) { + var item = getItem(id); + return item ? item.childIDs : []; + }, + getDisplayName: function(id) { + var element = ReactComponentTreeHook.getElement(id); + return element ? getDisplayName(element) : null; + }, + getElement: function(id) { + var item = getItem(id); + return item ? item.element : null; + }, + getOwnerID: function(id) { + var element = ReactComponentTreeHook.getElement(id); + return element && element._owner ? element._owner._debugID : null; + }, + getParentID: function(id) { + var item = getItem(id); + return item ? item.parentID : null; + }, + getSource: function(id) { + var item = getItem(id), element = item ? item.element : null, source = null != element ? element._source : null; + return source; + }, + getText: function(id) { + var element = ReactComponentTreeHook.getElement(id); + return "string" == typeof element ? element : "number" == typeof element ? "" + element : null; + }, + getUpdateCount: function(id) { + var item = getItem(id); + return item ? item.updateCount : 0; + }, + getRootIDs: getRootIDs, + getRegisteredIDs: getItemIDs, + pushNonStandardWarningStack: function(isCreatingElement, currentSource) { + if ("function" == typeof console.reactStack) { + var stack = [], currentOwner = ReactCurrentOwner.current, id = currentOwner && currentOwner._debugID; + try { + for (isCreatingElement && stack.push({ + name: id ? ReactComponentTreeHook.getDisplayName(id) : null, + fileName: currentSource ? currentSource.fileName : null, + lineNumber: currentSource ? currentSource.lineNumber : null + }); id; ) { + var element = ReactComponentTreeHook.getElement(id), parentID = ReactComponentTreeHook.getParentID(id), ownerID = ReactComponentTreeHook.getOwnerID(id), ownerName = ownerID ? ReactComponentTreeHook.getDisplayName(ownerID) : null, source = element && element._source; + stack.push({ + name: ownerName, + fileName: source ? source.fileName : null, + lineNumber: source ? source.lineNumber : null + }), id = parentID; + } + } catch (err) {} + console.reactStack(stack); + } + }, + popNonStandardWarningStack: function() { + "function" == typeof console.reactStackEnd && console.reactStackEnd(); + } + }; + module.exports = ReactComponentTreeHook; + }).call(exports, __webpack_require__(3)); +}, function(module, exports, __webpack_require__) { + (function(process) { + "use strict"; + function checkReactTypeSpec(typeSpecs, values, location, componentName, element, debugID) { + for (var typeSpecName in typeSpecs) if (typeSpecs.hasOwnProperty(typeSpecName)) { + var error; + try { + "function" != typeof typeSpecs[typeSpecName] ? "production" !== process.env.NODE_ENV ? invariant(!1, "%s: %s type `%s` is invalid; it must be a function, usually from React.PropTypes.", componentName || "React class", ReactPropTypeLocationNames[location], typeSpecName) : _prodInvariant("84", componentName || "React class", ReactPropTypeLocationNames[location], typeSpecName) : void 0, + error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret); + } catch (ex) { + error = ex; + } + if ("production" !== process.env.NODE_ENV ? warning(!error || error instanceof Error, "%s: type specification of %s `%s` is invalid; the type checker function must return `null` or an `Error` but returned a %s. You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument).", componentName || "React class", ReactPropTypeLocationNames[location], typeSpecName, typeof error) : void 0, + error instanceof Error && !(error.message in loggedTypeFailures)) { + loggedTypeFailures[error.message] = !0; + var componentStackInfo = ""; + "production" !== process.env.NODE_ENV && (ReactComponentTreeHook || (ReactComponentTreeHook = __webpack_require__(24)), + null !== debugID ? componentStackInfo = ReactComponentTreeHook.getStackAddendumByID(debugID) : null !== element && (componentStackInfo = ReactComponentTreeHook.getCurrentStackAddendum(element))), + "production" !== process.env.NODE_ENV ? warning(!1, "Failed %s type: %s%s", location, error.message, componentStackInfo) : void 0; + } + } + } + var ReactComponentTreeHook, _prodInvariant = __webpack_require__(6), ReactPropTypeLocationNames = __webpack_require__(26), ReactPropTypesSecret = __webpack_require__(27), invariant = __webpack_require__(12), warning = __webpack_require__(8); + "undefined" != typeof process && process.env && "test" === process.env.NODE_ENV && (ReactComponentTreeHook = __webpack_require__(24)); + var loggedTypeFailures = {}; + module.exports = checkReactTypeSpec; + }).call(exports, __webpack_require__(3)); +}, function(module, exports, __webpack_require__) { + (function(process) { + "use strict"; + var ReactPropTypeLocationNames = {}; + "production" !== process.env.NODE_ENV && (ReactPropTypeLocationNames = { + prop: "prop", + context: "context", + childContext: "child context" + }), module.exports = ReactPropTypeLocationNames; + }).call(exports, __webpack_require__(3)); +}, function(module, exports) { + "use strict"; + var ReactPropTypesSecret = "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED"; + module.exports = ReactPropTypesSecret; +}, function(module, exports, __webpack_require__) { + "use strict"; + var _require = __webpack_require__(16), isValidElement = _require.isValidElement, factory = __webpack_require__(29); + module.exports = factory(isValidElement); +}, function(module, exports, __webpack_require__) { + "use strict"; + var factory = __webpack_require__(30); + module.exports = function(isValidElement) { + var throwOnDirectAccess = !1; + return factory(isValidElement, throwOnDirectAccess); + }; +}, function(module, exports, __webpack_require__) { + (function(process) { + "use strict"; + var emptyFunction = __webpack_require__(9), invariant = __webpack_require__(12), warning = __webpack_require__(8), ReactPropTypesSecret = __webpack_require__(31), checkPropTypes = __webpack_require__(32); + module.exports = function(isValidElement, throwOnDirectAccess) { + function getIteratorFn(maybeIterable) { + var iteratorFn = maybeIterable && (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]); + if ("function" == typeof iteratorFn) return iteratorFn; + } + function is(x, y) { + return x === y ? 0 !== x || 1 / x === 1 / y : x !== x && y !== y; + } + function PropTypeError(message) { + this.message = message, this.stack = ""; + } + function createChainableTypeChecker(validate) { + function checkType(isRequired, props, propName, componentName, location, propFullName, secret) { + if (componentName = componentName || ANONYMOUS, propFullName = propFullName || propName, + secret !== ReactPropTypesSecret) if (throwOnDirectAccess) invariant(!1, "Calling PropTypes validators directly is not supported by the `prop-types` package. Use `PropTypes.checkPropTypes()` to call them. Read more at http://fb.me/use-check-prop-types"); else if ("production" !== process.env.NODE_ENV && "undefined" != typeof console) { + var cacheKey = componentName + ":" + propName; + !manualPropTypeCallCache[cacheKey] && manualPropTypeWarningCount < 3 && (warning(!1, "You are manually calling a React.PropTypes validation function for the `%s` prop on `%s`. This is deprecated and will throw in the standalone `prop-types` package. You may be seeing this warning due to a third-party PropTypes library. See https://fb.me/react-warning-dont-call-proptypes for details.", propFullName, componentName), + manualPropTypeCallCache[cacheKey] = !0, manualPropTypeWarningCount++); + } + return null == props[propName] ? isRequired ? new PropTypeError(null === props[propName] ? "The " + location + " `" + propFullName + "` is marked as required " + ("in `" + componentName + "`, but its value is `null`.") : "The " + location + " `" + propFullName + "` is marked as required in " + ("`" + componentName + "`, but its value is `undefined`.")) : null : validate(props, propName, componentName, location, propFullName); + } + if ("production" !== process.env.NODE_ENV) var manualPropTypeCallCache = {}, manualPropTypeWarningCount = 0; + var chainedCheckType = checkType.bind(null, !1); + return chainedCheckType.isRequired = checkType.bind(null, !0), chainedCheckType; + } + function createPrimitiveTypeChecker(expectedType) { + function validate(props, propName, componentName, location, propFullName, secret) { + var propValue = props[propName], propType = getPropType(propValue); + if (propType !== expectedType) { + var preciseType = getPreciseType(propValue); + return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type " + ("`" + preciseType + "` supplied to `" + componentName + "`, expected ") + ("`" + expectedType + "`.")); + } + return null; + } + return createChainableTypeChecker(validate); + } + function createAnyTypeChecker() { + return createChainableTypeChecker(emptyFunction.thatReturnsNull); + } + function createArrayOfTypeChecker(typeChecker) { + function validate(props, propName, componentName, location, propFullName) { + if ("function" != typeof typeChecker) return new PropTypeError("Property `" + propFullName + "` of component `" + componentName + "` has invalid PropType notation inside arrayOf."); + var propValue = props[propName]; + if (!Array.isArray(propValue)) { + var propType = getPropType(propValue); + return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type " + ("`" + propType + "` supplied to `" + componentName + "`, expected an array.")); + } + for (var i = 0; i < propValue.length; i++) { + var error = typeChecker(propValue, i, componentName, location, propFullName + "[" + i + "]", ReactPropTypesSecret); + if (error instanceof Error) return error; + } + return null; + } + return createChainableTypeChecker(validate); + } + function createElementTypeChecker() { + function validate(props, propName, componentName, location, propFullName) { + var propValue = props[propName]; + if (!isValidElement(propValue)) { + var propType = getPropType(propValue); + return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type " + ("`" + propType + "` supplied to `" + componentName + "`, expected a single ReactElement.")); + } + return null; + } + return createChainableTypeChecker(validate); + } + function createInstanceTypeChecker(expectedClass) { + function validate(props, propName, componentName, location, propFullName) { + if (!(props[propName] instanceof expectedClass)) { + var expectedClassName = expectedClass.name || ANONYMOUS, actualClassName = getClassName(props[propName]); + return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type " + ("`" + actualClassName + "` supplied to `" + componentName + "`, expected ") + ("instance of `" + expectedClassName + "`.")); + } + return null; + } + return createChainableTypeChecker(validate); + } + function createEnumTypeChecker(expectedValues) { + function validate(props, propName, componentName, location, propFullName) { + for (var propValue = props[propName], i = 0; i < expectedValues.length; i++) if (is(propValue, expectedValues[i])) return null; + var valuesString = JSON.stringify(expectedValues); + return new PropTypeError("Invalid " + location + " `" + propFullName + "` of value `" + propValue + "` " + ("supplied to `" + componentName + "`, expected one of " + valuesString + ".")); + } + return Array.isArray(expectedValues) ? createChainableTypeChecker(validate) : ("production" !== process.env.NODE_ENV ? warning(!1, "Invalid argument supplied to oneOf, expected an instance of array.") : void 0, + emptyFunction.thatReturnsNull); + } + function createObjectOfTypeChecker(typeChecker) { + function validate(props, propName, componentName, location, propFullName) { + if ("function" != typeof typeChecker) return new PropTypeError("Property `" + propFullName + "` of component `" + componentName + "` has invalid PropType notation inside objectOf."); + var propValue = props[propName], propType = getPropType(propValue); + if ("object" !== propType) return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type " + ("`" + propType + "` supplied to `" + componentName + "`, expected an object.")); + for (var key in propValue) if (propValue.hasOwnProperty(key)) { + var error = typeChecker(propValue, key, componentName, location, propFullName + "." + key, ReactPropTypesSecret); + if (error instanceof Error) return error; + } + return null; + } + return createChainableTypeChecker(validate); + } + function createUnionTypeChecker(arrayOfTypeCheckers) { + function validate(props, propName, componentName, location, propFullName) { + for (var i = 0; i < arrayOfTypeCheckers.length; i++) { + var checker = arrayOfTypeCheckers[i]; + if (null == checker(props, propName, componentName, location, propFullName, ReactPropTypesSecret)) return null; + } + return new PropTypeError("Invalid " + location + " `" + propFullName + "` supplied to " + ("`" + componentName + "`.")); + } + if (!Array.isArray(arrayOfTypeCheckers)) return "production" !== process.env.NODE_ENV ? warning(!1, "Invalid argument supplied to oneOfType, expected an instance of array.") : void 0, + emptyFunction.thatReturnsNull; + for (var i = 0; i < arrayOfTypeCheckers.length; i++) { + var checker = arrayOfTypeCheckers[i]; + if ("function" != typeof checker) return warning(!1, "Invalid argument supplid to oneOfType. Expected an array of check functions, but received %s at index %s.", getPostfixForTypeWarning(checker), i), + emptyFunction.thatReturnsNull; + } + return createChainableTypeChecker(validate); + } + function createNodeChecker() { + function validate(props, propName, componentName, location, propFullName) { + return isNode(props[propName]) ? null : new PropTypeError("Invalid " + location + " `" + propFullName + "` supplied to " + ("`" + componentName + "`, expected a ReactNode.")); + } + return createChainableTypeChecker(validate); + } + function createShapeTypeChecker(shapeTypes) { + function validate(props, propName, componentName, location, propFullName) { + var propValue = props[propName], propType = getPropType(propValue); + if ("object" !== propType) return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type `" + propType + "` " + ("supplied to `" + componentName + "`, expected `object`.")); + for (var key in shapeTypes) { + var checker = shapeTypes[key]; + if (checker) { + var error = checker(propValue, key, componentName, location, propFullName + "." + key, ReactPropTypesSecret); + if (error) return error; + } + } + return null; + } + return createChainableTypeChecker(validate); + } + function isNode(propValue) { + switch (typeof propValue) { + case "number": + case "string": + case "undefined": + return !0; + + case "boolean": + return !propValue; + + case "object": + if (Array.isArray(propValue)) return propValue.every(isNode); + if (null === propValue || isValidElement(propValue)) return !0; + var iteratorFn = getIteratorFn(propValue); + if (!iteratorFn) return !1; + var step, iterator = iteratorFn.call(propValue); + if (iteratorFn !== propValue.entries) { + for (;!(step = iterator.next()).done; ) if (!isNode(step.value)) return !1; + } else for (;!(step = iterator.next()).done; ) { + var entry = step.value; + if (entry && !isNode(entry[1])) return !1; + } + return !0; + + default: + return !1; + } + } + function isSymbol(propType, propValue) { + return "symbol" === propType || ("Symbol" === propValue["@@toStringTag"] || "function" == typeof Symbol && propValue instanceof Symbol); + } + function getPropType(propValue) { + var propType = typeof propValue; + return Array.isArray(propValue) ? "array" : propValue instanceof RegExp ? "object" : isSymbol(propType, propValue) ? "symbol" : propType; + } + function getPreciseType(propValue) { + if ("undefined" == typeof propValue || null === propValue) return "" + propValue; + var propType = getPropType(propValue); + if ("object" === propType) { + if (propValue instanceof Date) return "date"; + if (propValue instanceof RegExp) return "regexp"; + } + return propType; + } + function getPostfixForTypeWarning(value) { + var type = getPreciseType(value); + switch (type) { + case "array": + case "object": + return "an " + type; + + case "boolean": + case "date": + case "regexp": + return "a " + type; + + default: + return type; + } + } + function getClassName(propValue) { + return propValue.constructor && propValue.constructor.name ? propValue.constructor.name : ANONYMOUS; + } + var ITERATOR_SYMBOL = "function" == typeof Symbol && Symbol.iterator, FAUX_ITERATOR_SYMBOL = "@@iterator", ANONYMOUS = "<>", ReactPropTypes = { + array: createPrimitiveTypeChecker("array"), + bool: createPrimitiveTypeChecker("boolean"), + func: createPrimitiveTypeChecker("function"), + number: createPrimitiveTypeChecker("number"), + object: createPrimitiveTypeChecker("object"), + string: createPrimitiveTypeChecker("string"), + symbol: createPrimitiveTypeChecker("symbol"), + any: createAnyTypeChecker(), + arrayOf: createArrayOfTypeChecker, + element: createElementTypeChecker(), + instanceOf: createInstanceTypeChecker, + node: createNodeChecker(), + objectOf: createObjectOfTypeChecker, + oneOf: createEnumTypeChecker, + oneOfType: createUnionTypeChecker, + shape: createShapeTypeChecker + }; + return PropTypeError.prototype = Error.prototype, ReactPropTypes.checkPropTypes = checkPropTypes, + ReactPropTypes.PropTypes = ReactPropTypes, ReactPropTypes; + }; + }).call(exports, __webpack_require__(3)); +}, function(module, exports) { + "use strict"; + var ReactPropTypesSecret = "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED"; + module.exports = ReactPropTypesSecret; +}, function(module, exports, __webpack_require__) { + (function(process) { + "use strict"; + function checkPropTypes(typeSpecs, values, location, componentName, getStack) { + if ("production" !== process.env.NODE_ENV) for (var typeSpecName in typeSpecs) if (typeSpecs.hasOwnProperty(typeSpecName)) { + var error; + try { + invariant("function" == typeof typeSpecs[typeSpecName], "%s: %s type `%s` is invalid; it must be a function, usually from React.PropTypes.", componentName || "React class", location, typeSpecName), + error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret); + } catch (ex) { + error = ex; + } + if (warning(!error || error instanceof Error, "%s: type specification of %s `%s` is invalid; the type checker function must return `null` or an `Error` but returned a %s. You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument).", componentName || "React class", location, typeSpecName, typeof error), + error instanceof Error && !(error.message in loggedTypeFailures)) { + loggedTypeFailures[error.message] = !0; + var stack = getStack ? getStack() : ""; + warning(!1, "Failed %s type: %s%s", location, error.message, null != stack ? stack : ""); + } + } + } + if ("production" !== process.env.NODE_ENV) var invariant = __webpack_require__(12), warning = __webpack_require__(8), ReactPropTypesSecret = __webpack_require__(31), loggedTypeFailures = {}; + module.exports = checkPropTypes; + }).call(exports, __webpack_require__(3)); +}, function(module, exports) { + "use strict"; + module.exports = "15.6.1"; +}, function(module, exports, __webpack_require__) { + "use strict"; + var _require = __webpack_require__(5), Component = _require.Component, _require2 = __webpack_require__(16), isValidElement = _require2.isValidElement, ReactNoopUpdateQueue = __webpack_require__(7), factory = __webpack_require__(35); + module.exports = factory(Component, isValidElement, ReactNoopUpdateQueue); +}, function(module, exports, __webpack_require__) { + (function(process) { + "use strict"; + function identity(fn) { + return fn; + } + function factory(ReactComponent, isValidElement, ReactNoopUpdateQueue) { + function validateTypeDef(Constructor, typeDef, location) { + for (var propName in typeDef) typeDef.hasOwnProperty(propName) && "production" !== process.env.NODE_ENV && warning("function" == typeof typeDef[propName], "%s: %s type `%s` is invalid; it must be a function, usually from React.PropTypes.", Constructor.displayName || "ReactClass", ReactPropTypeLocationNames[location], propName); + } + function validateMethodOverride(isAlreadyDefined, name) { + var specPolicy = ReactClassInterface.hasOwnProperty(name) ? ReactClassInterface[name] : null; + ReactClassMixin.hasOwnProperty(name) && _invariant("OVERRIDE_BASE" === specPolicy, "ReactClassInterface: You are attempting to override `%s` from your class specification. Ensure that your method names do not overlap with React methods.", name), + isAlreadyDefined && _invariant("DEFINE_MANY" === specPolicy || "DEFINE_MANY_MERGED" === specPolicy, "ReactClassInterface: You are attempting to define `%s` on your component more than once. This conflict may be due to a mixin.", name); + } + function mixSpecIntoComponent(Constructor, spec) { + if (spec) { + _invariant("function" != typeof spec, "ReactClass: You're attempting to use a component class or function as a mixin. Instead, just use a regular object."), + _invariant(!isValidElement(spec), "ReactClass: You're attempting to use a component as a mixin. Instead, just use a regular object."); + var proto = Constructor.prototype, autoBindPairs = proto.__reactAutoBindPairs; + spec.hasOwnProperty(MIXINS_KEY) && RESERVED_SPEC_KEYS.mixins(Constructor, spec.mixins); + for (var name in spec) if (spec.hasOwnProperty(name) && name !== MIXINS_KEY) { + var property = spec[name], isAlreadyDefined = proto.hasOwnProperty(name); + if (validateMethodOverride(isAlreadyDefined, name), RESERVED_SPEC_KEYS.hasOwnProperty(name)) RESERVED_SPEC_KEYS[name](Constructor, property); else { + var isReactClassMethod = ReactClassInterface.hasOwnProperty(name), isFunction = "function" == typeof property, shouldAutoBind = isFunction && !isReactClassMethod && !isAlreadyDefined && spec.autobind !== !1; + if (shouldAutoBind) autoBindPairs.push(name, property), proto[name] = property; else if (isAlreadyDefined) { + var specPolicy = ReactClassInterface[name]; + _invariant(isReactClassMethod && ("DEFINE_MANY_MERGED" === specPolicy || "DEFINE_MANY" === specPolicy), "ReactClass: Unexpected spec policy %s for key %s when mixing in component specs.", specPolicy, name), + "DEFINE_MANY_MERGED" === specPolicy ? proto[name] = createMergedResultFunction(proto[name], property) : "DEFINE_MANY" === specPolicy && (proto[name] = createChainedFunction(proto[name], property)); + } else proto[name] = property, "production" !== process.env.NODE_ENV && "function" == typeof property && spec.displayName && (proto[name].displayName = spec.displayName + "_" + name); + } + } + } else if ("production" !== process.env.NODE_ENV) { + var typeofSpec = typeof spec, isMixinValid = "object" === typeofSpec && null !== spec; + "production" !== process.env.NODE_ENV && warning(isMixinValid, "%s: You're attempting to include a mixin that is either null or not an object. Check the mixins included by the component, as well as any mixins they include themselves. Expected object but got %s.", Constructor.displayName || "ReactClass", null === spec ? null : typeofSpec); + } + } + function mixStaticSpecIntoComponent(Constructor, statics) { + if (statics) for (var name in statics) { + var property = statics[name]; + if (statics.hasOwnProperty(name)) { + var isReserved = name in RESERVED_SPEC_KEYS; + _invariant(!isReserved, '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.', name); + var isInherited = name in Constructor; + _invariant(!isInherited, "ReactClass: You are attempting to define `%s` on your component more than once. This conflict may be due to a mixin.", name), + Constructor[name] = property; + } + } + } + function mergeIntoWithNoDuplicateKeys(one, two) { + _invariant(one && two && "object" == typeof one && "object" == typeof two, "mergeIntoWithNoDuplicateKeys(): Cannot merge non-objects."); + for (var key in two) two.hasOwnProperty(key) && (_invariant(void 0 === one[key], "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.", key), + one[key] = two[key]); + return one; + } + function createMergedResultFunction(one, two) { + return function() { + var a = one.apply(this, arguments), b = two.apply(this, arguments); + if (null == a) return b; + if (null == b) return a; + var c = {}; + return mergeIntoWithNoDuplicateKeys(c, a), mergeIntoWithNoDuplicateKeys(c, b), c; + }; + } + function createChainedFunction(one, two) { + return function() { + one.apply(this, arguments), two.apply(this, arguments); + }; + } + function bindAutoBindMethod(component, method) { + var boundMethod = method.bind(component); + if ("production" !== process.env.NODE_ENV) { + boundMethod.__reactBoundContext = component, boundMethod.__reactBoundMethod = method, + boundMethod.__reactBoundArguments = null; + var componentName = component.constructor.displayName, _bind = boundMethod.bind; + boundMethod.bind = function(newThis) { + for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) args[_key - 1] = arguments[_key]; + if (newThis !== component && null !== newThis) "production" !== process.env.NODE_ENV && warning(!1, "bind(): React component methods may only be bound to the component instance. See %s", componentName); else if (!args.length) return "production" !== process.env.NODE_ENV && warning(!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", componentName), + boundMethod; + var reboundMethod = _bind.apply(boundMethod, arguments); + return reboundMethod.__reactBoundContext = component, reboundMethod.__reactBoundMethod = method, + reboundMethod.__reactBoundArguments = args, reboundMethod; + }; + } + return boundMethod; + } + function bindAutoBindMethods(component) { + for (var pairs = component.__reactAutoBindPairs, i = 0; i < pairs.length; i += 2) { + var autoBindKey = pairs[i], method = pairs[i + 1]; + component[autoBindKey] = bindAutoBindMethod(component, method); + } + } + function createClass(spec) { + var Constructor = identity(function(props, context, updater) { + "production" !== process.env.NODE_ENV && warning(this instanceof Constructor, "Something is calling a React component directly. Use a factory or JSX instead. See: https://fb.me/react-legacyfactory"), + this.__reactAutoBindPairs.length && bindAutoBindMethods(this), this.props = props, + this.context = context, this.refs = emptyObject, this.updater = updater || ReactNoopUpdateQueue, + this.state = null; + var initialState = this.getInitialState ? this.getInitialState() : null; + "production" !== process.env.NODE_ENV && void 0 === initialState && this.getInitialState._isMockFunction && (initialState = null), + _invariant("object" == typeof initialState && !Array.isArray(initialState), "%s.getInitialState(): must return an object or null", Constructor.displayName || "ReactCompositeComponent"), + this.state = initialState; + }); + Constructor.prototype = new ReactClassComponent(), Constructor.prototype.constructor = Constructor, + Constructor.prototype.__reactAutoBindPairs = [], injectedMixins.forEach(mixSpecIntoComponent.bind(null, Constructor)), + mixSpecIntoComponent(Constructor, IsMountedPreMixin), mixSpecIntoComponent(Constructor, spec), + mixSpecIntoComponent(Constructor, IsMountedPostMixin), Constructor.getDefaultProps && (Constructor.defaultProps = Constructor.getDefaultProps()), + "production" !== process.env.NODE_ENV && (Constructor.getDefaultProps && (Constructor.getDefaultProps.isReactClassApproved = {}), + Constructor.prototype.getInitialState && (Constructor.prototype.getInitialState.isReactClassApproved = {})), + _invariant(Constructor.prototype.render, "createClass(...): Class specification must implement a `render` method."), + "production" !== process.env.NODE_ENV && (warning(!Constructor.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.", spec.displayName || "A component"), + warning(!Constructor.prototype.componentWillRecieveProps, "%s has a method called componentWillRecieveProps(). Did you mean componentWillReceiveProps()?", spec.displayName || "A component")); + for (var methodName in ReactClassInterface) Constructor.prototype[methodName] || (Constructor.prototype[methodName] = null); + return Constructor; + } + var injectedMixins = [], ReactClassInterface = { + mixins: "DEFINE_MANY", + statics: "DEFINE_MANY", + propTypes: "DEFINE_MANY", + contextTypes: "DEFINE_MANY", + childContextTypes: "DEFINE_MANY", + getDefaultProps: "DEFINE_MANY_MERGED", + getInitialState: "DEFINE_MANY_MERGED", + getChildContext: "DEFINE_MANY_MERGED", + render: "DEFINE_ONCE", + componentWillMount: "DEFINE_MANY", + componentDidMount: "DEFINE_MANY", + componentWillReceiveProps: "DEFINE_MANY", + shouldComponentUpdate: "DEFINE_ONCE", + componentWillUpdate: "DEFINE_MANY", + componentDidUpdate: "DEFINE_MANY", + componentWillUnmount: "DEFINE_MANY", + updateComponent: "OVERRIDE_BASE" + }, RESERVED_SPEC_KEYS = { + displayName: function(Constructor, displayName) { + Constructor.displayName = displayName; + }, + mixins: function(Constructor, mixins) { + if (mixins) for (var i = 0; i < mixins.length; i++) mixSpecIntoComponent(Constructor, mixins[i]); + }, + childContextTypes: function(Constructor, childContextTypes) { + "production" !== process.env.NODE_ENV && validateTypeDef(Constructor, childContextTypes, "childContext"), + Constructor.childContextTypes = _assign({}, Constructor.childContextTypes, childContextTypes); + }, + contextTypes: function(Constructor, contextTypes) { + "production" !== process.env.NODE_ENV && validateTypeDef(Constructor, contextTypes, "context"), + Constructor.contextTypes = _assign({}, Constructor.contextTypes, contextTypes); + }, + getDefaultProps: function(Constructor, getDefaultProps) { + Constructor.getDefaultProps ? Constructor.getDefaultProps = createMergedResultFunction(Constructor.getDefaultProps, getDefaultProps) : Constructor.getDefaultProps = getDefaultProps; + }, + propTypes: function(Constructor, propTypes) { + "production" !== process.env.NODE_ENV && validateTypeDef(Constructor, propTypes, "prop"), + Constructor.propTypes = _assign({}, Constructor.propTypes, propTypes); + }, + statics: function(Constructor, statics) { + mixStaticSpecIntoComponent(Constructor, statics); + }, + autobind: function() {} + }, IsMountedPreMixin = { + componentDidMount: function() { + this.__isMounted = !0; + } + }, IsMountedPostMixin = { + componentWillUnmount: function() { + this.__isMounted = !1; + } + }, ReactClassMixin = { + replaceState: function(newState, callback) { + this.updater.enqueueReplaceState(this, newState, callback); + }, + isMounted: function() { + return "production" !== process.env.NODE_ENV && (warning(this.__didWarnIsMounted, "%s: isMounted is deprecated. Instead, make sure to clean up subscriptions and pending requests in componentWillUnmount to prevent memory leaks.", this.constructor && this.constructor.displayName || this.name || "Component"), + this.__didWarnIsMounted = !0), !!this.__isMounted; + } + }, ReactClassComponent = function() {}; + return _assign(ReactClassComponent.prototype, ReactComponent.prototype, ReactClassMixin), + createClass; + } + var _assign = __webpack_require__(4), emptyObject = __webpack_require__(11), _invariant = __webpack_require__(12); + if ("production" !== process.env.NODE_ENV) var warning = __webpack_require__(8); + var ReactPropTypeLocationNames, MIXINS_KEY = "mixins"; + ReactPropTypeLocationNames = "production" !== process.env.NODE_ENV ? { + prop: "prop", + context: "context", + childContext: "child context" + } : {}, module.exports = factory; + }).call(exports, __webpack_require__(3)); +}, function(module, exports, __webpack_require__) { + (function(process) { + "use strict"; + function onlyChild(children) { + return ReactElement.isValidElement(children) ? void 0 : "production" !== process.env.NODE_ENV ? invariant(!1, "React.Children.only expected to receive a single React element child.") : _prodInvariant("143"), + children; + } + var _prodInvariant = __webpack_require__(6), ReactElement = __webpack_require__(16), invariant = __webpack_require__(12); + module.exports = onlyChild; + }).call(exports, __webpack_require__(3)); +}, function(module, exports, __webpack_require__) { + "use strict"; + module.exports = __webpack_require__(38); +}, function(module, exports, __webpack_require__) { + (function(process) { + "use strict"; + var ReactDOMComponentTree = __webpack_require__(39), ReactDefaultInjection = __webpack_require__(43), ReactMount = __webpack_require__(172), ReactReconciler = __webpack_require__(64), ReactUpdates = __webpack_require__(61), ReactVersion = __webpack_require__(177), findDOMNode = __webpack_require__(178), getHostComponentFromComposite = __webpack_require__(179), renderSubtreeIntoContainer = __webpack_require__(180), warning = __webpack_require__(8); + ReactDefaultInjection.inject(); + var ReactDOM = { + findDOMNode: findDOMNode, + render: ReactMount.render, + unmountComponentAtNode: ReactMount.unmountComponentAtNode, + version: ReactVersion, + unstable_batchedUpdates: ReactUpdates.batchedUpdates, + unstable_renderSubtreeIntoContainer: renderSubtreeIntoContainer + }; + if ("undefined" != typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" == typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.inject && __REACT_DEVTOOLS_GLOBAL_HOOK__.inject({ + ComponentTree: { + getClosestInstanceFromNode: ReactDOMComponentTree.getClosestInstanceFromNode, + getNodeFromInstance: function(inst) { + return inst._renderedComponent && (inst = getHostComponentFromComposite(inst)), + inst ? ReactDOMComponentTree.getNodeFromInstance(inst) : null; + } + }, + Mount: ReactMount, + Reconciler: ReactReconciler + }), "production" !== process.env.NODE_ENV) { + var ExecutionEnvironment = __webpack_require__(53); + if (ExecutionEnvironment.canUseDOM && window.top === window.self) { + if ("undefined" == typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && (navigator.userAgent.indexOf("Chrome") > -1 && navigator.userAgent.indexOf("Edge") === -1 || navigator.userAgent.indexOf("Firefox") > -1)) { + var showFileUrlMessage = window.location.protocol.indexOf("http") === -1 && navigator.userAgent.indexOf("Firefox") === -1; + console.debug("Download the React DevTools " + (showFileUrlMessage ? "and use an HTTP server (instead of a file: URL) " : "") + "for a better development experience: https://fb.me/react-devtools"); + } + var testFunc = function() {}; + "production" !== process.env.NODE_ENV ? warning((testFunc.name || testFunc.toString()).indexOf("testFn") !== -1, "It looks like you're using a minified copy of the development build of React. When deploying React apps to production, make sure to use the production build which skips development warnings and is faster. See https://fb.me/react-minification for more details.") : void 0; + var ieCompatibilityMode = document.documentMode && document.documentMode < 8; + "production" !== process.env.NODE_ENV ? warning(!ieCompatibilityMode, 'Internet Explorer is running in compatibility mode; please add the following tag to your HTML to prevent this from happening: ') : void 0; + for (var expectedFeatures = [ Array.isArray, Array.prototype.every, Array.prototype.forEach, Array.prototype.indexOf, Array.prototype.map, Date.now, Function.prototype.bind, Object.keys, String.prototype.trim ], i = 0; i < expectedFeatures.length; i++) if (!expectedFeatures[i]) { + "production" !== process.env.NODE_ENV ? warning(!1, "One or more ES5 shims expected by React are not available: https://fb.me/react-warning-polyfills") : void 0; + break; + } + } + } + if ("production" !== process.env.NODE_ENV) { + var ReactInstrumentation = __webpack_require__(67), ReactDOMUnknownPropertyHook = __webpack_require__(181), ReactDOMNullInputValuePropHook = __webpack_require__(182), ReactDOMInvalidARIAHook = __webpack_require__(183); + ReactInstrumentation.debugTool.addHook(ReactDOMUnknownPropertyHook), ReactInstrumentation.debugTool.addHook(ReactDOMNullInputValuePropHook), + ReactInstrumentation.debugTool.addHook(ReactDOMInvalidARIAHook); + } + module.exports = ReactDOM; + }).call(exports, __webpack_require__(3)); +}, function(module, exports, __webpack_require__) { + (function(process) { + "use strict"; + function shouldPrecacheNode(node, nodeID) { + return 1 === node.nodeType && node.getAttribute(ATTR_NAME) === String(nodeID) || 8 === node.nodeType && node.nodeValue === " react-text: " + nodeID + " " || 8 === node.nodeType && node.nodeValue === " react-empty: " + nodeID + " "; + } + function getRenderedHostOrTextFromComponent(component) { + for (var rendered; rendered = component._renderedComponent; ) component = rendered; + return component; + } + function precacheNode(inst, node) { + var hostInst = getRenderedHostOrTextFromComponent(inst); + hostInst._hostNode = node, node[internalInstanceKey] = hostInst; + } + function uncacheNode(inst) { + var node = inst._hostNode; + node && (delete node[internalInstanceKey], inst._hostNode = null); + } + function precacheChildNodes(inst, node) { + if (!(inst._flags & Flags.hasCachedChildNodes)) { + var children = inst._renderedChildren, childNode = node.firstChild; + outer: for (var name in children) if (children.hasOwnProperty(name)) { + var childInst = children[name], childID = getRenderedHostOrTextFromComponent(childInst)._domID; + if (0 !== childID) { + for (;null !== childNode; childNode = childNode.nextSibling) if (shouldPrecacheNode(childNode, childID)) { + precacheNode(childInst, childNode); + continue outer; + } + "production" !== process.env.NODE_ENV ? invariant(!1, "Unable to find element with ID %s.", childID) : _prodInvariant("32", childID); + } + } + inst._flags |= Flags.hasCachedChildNodes; + } + } + function getClosestInstanceFromNode(node) { + if (node[internalInstanceKey]) return node[internalInstanceKey]; + for (var parents = []; !node[internalInstanceKey]; ) { + if (parents.push(node), !node.parentNode) return null; + node = node.parentNode; + } + for (var closest, inst; node && (inst = node[internalInstanceKey]); node = parents.pop()) closest = inst, + parents.length && precacheChildNodes(inst, node); + return closest; + } + function getInstanceFromNode(node) { + var inst = getClosestInstanceFromNode(node); + return null != inst && inst._hostNode === node ? inst : null; + } + function getNodeFromInstance(inst) { + if (void 0 === inst._hostNode ? "production" !== process.env.NODE_ENV ? invariant(!1, "getNodeFromInstance: Invalid argument.") : _prodInvariant("33") : void 0, + inst._hostNode) return inst._hostNode; + for (var parents = []; !inst._hostNode; ) parents.push(inst), inst._hostParent ? void 0 : "production" !== process.env.NODE_ENV ? invariant(!1, "React DOM tree root should always have a node reference.") : _prodInvariant("34"), + inst = inst._hostParent; + for (;parents.length; inst = parents.pop()) precacheChildNodes(inst, inst._hostNode); + return inst._hostNode; + } + var _prodInvariant = __webpack_require__(40), DOMProperty = __webpack_require__(41), ReactDOMComponentFlags = __webpack_require__(42), invariant = __webpack_require__(12), ATTR_NAME = DOMProperty.ID_ATTRIBUTE_NAME, Flags = ReactDOMComponentFlags, internalInstanceKey = "__reactInternalInstance$" + Math.random().toString(36).slice(2), ReactDOMComponentTree = { + getClosestInstanceFromNode: getClosestInstanceFromNode, + getInstanceFromNode: getInstanceFromNode, + getNodeFromInstance: getNodeFromInstance, + precacheChildNodes: precacheChildNodes, + precacheNode: precacheNode, + uncacheNode: uncacheNode + }; + module.exports = ReactDOMComponentTree; + }).call(exports, __webpack_require__(3)); +}, function(module, exports) { + "use strict"; + function reactProdInvariant(code) { + for (var argCount = arguments.length - 1, message = "Minified React error #" + code + "; visit http://facebook.github.io/react/docs/error-decoder.html?invariant=" + code, argIdx = 0; argIdx < argCount; argIdx++) message += "&args[]=" + encodeURIComponent(arguments[argIdx + 1]); + message += " for the full message or use the non-minified dev environment for full errors and additional helpful warnings."; + var error = new Error(message); + throw error.name = "Invariant Violation", error.framesToPop = 1, error; + } + module.exports = reactProdInvariant; +}, function(module, exports, __webpack_require__) { + (function(process) { + "use strict"; + function checkMask(value, bitmask) { + return (value & bitmask) === bitmask; + } + var _prodInvariant = __webpack_require__(40), invariant = __webpack_require__(12), DOMPropertyInjection = { + MUST_USE_PROPERTY: 1, + HAS_BOOLEAN_VALUE: 4, + HAS_NUMERIC_VALUE: 8, + HAS_POSITIVE_NUMERIC_VALUE: 24, + HAS_OVERLOADED_BOOLEAN_VALUE: 32, + injectDOMPropertyConfig: function(domPropertyConfig) { + var Injection = DOMPropertyInjection, Properties = domPropertyConfig.Properties || {}, DOMAttributeNamespaces = domPropertyConfig.DOMAttributeNamespaces || {}, DOMAttributeNames = domPropertyConfig.DOMAttributeNames || {}, DOMPropertyNames = domPropertyConfig.DOMPropertyNames || {}, DOMMutationMethods = domPropertyConfig.DOMMutationMethods || {}; + domPropertyConfig.isCustomAttribute && DOMProperty._isCustomAttributeFunctions.push(domPropertyConfig.isCustomAttribute); + for (var propName in Properties) { + DOMProperty.properties.hasOwnProperty(propName) ? "production" !== process.env.NODE_ENV ? invariant(!1, "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.", propName) : _prodInvariant("48", propName) : void 0; + var lowerCased = propName.toLowerCase(), propConfig = Properties[propName], propertyInfo = { + attributeName: lowerCased, + attributeNamespace: null, + propertyName: propName, + mutationMethod: null, + mustUseProperty: checkMask(propConfig, Injection.MUST_USE_PROPERTY), + hasBooleanValue: checkMask(propConfig, Injection.HAS_BOOLEAN_VALUE), + hasNumericValue: checkMask(propConfig, Injection.HAS_NUMERIC_VALUE), + hasPositiveNumericValue: checkMask(propConfig, Injection.HAS_POSITIVE_NUMERIC_VALUE), + hasOverloadedBooleanValue: checkMask(propConfig, Injection.HAS_OVERLOADED_BOOLEAN_VALUE) + }; + if (propertyInfo.hasBooleanValue + propertyInfo.hasNumericValue + propertyInfo.hasOverloadedBooleanValue <= 1 ? void 0 : "production" !== process.env.NODE_ENV ? invariant(!1, "DOMProperty: Value can be one of boolean, overloaded boolean, or numeric value, but not a combination: %s", propName) : _prodInvariant("50", propName), + "production" !== process.env.NODE_ENV && (DOMProperty.getPossibleStandardName[lowerCased] = propName), + DOMAttributeNames.hasOwnProperty(propName)) { + var attributeName = DOMAttributeNames[propName]; + propertyInfo.attributeName = attributeName, "production" !== process.env.NODE_ENV && (DOMProperty.getPossibleStandardName[attributeName] = propName); + } + DOMAttributeNamespaces.hasOwnProperty(propName) && (propertyInfo.attributeNamespace = DOMAttributeNamespaces[propName]), + DOMPropertyNames.hasOwnProperty(propName) && (propertyInfo.propertyName = DOMPropertyNames[propName]), + DOMMutationMethods.hasOwnProperty(propName) && (propertyInfo.mutationMethod = DOMMutationMethods[propName]), + DOMProperty.properties[propName] = propertyInfo; + } + } + }, ATTRIBUTE_NAME_START_CHAR = ":A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD", DOMProperty = { + ID_ATTRIBUTE_NAME: "data-reactid", + ROOT_ATTRIBUTE_NAME: "data-reactroot", + ATTRIBUTE_NAME_START_CHAR: ATTRIBUTE_NAME_START_CHAR, + ATTRIBUTE_NAME_CHAR: ATTRIBUTE_NAME_START_CHAR + "\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040", + properties: {}, + getPossibleStandardName: "production" !== process.env.NODE_ENV ? { + autofocus: "autoFocus" + } : null, + _isCustomAttributeFunctions: [], + isCustomAttribute: function(attributeName) { + for (var i = 0; i < DOMProperty._isCustomAttributeFunctions.length; i++) { + var isCustomAttributeFn = DOMProperty._isCustomAttributeFunctions[i]; + if (isCustomAttributeFn(attributeName)) return !0; + } + return !1; + }, + injection: DOMPropertyInjection + }; + module.exports = DOMProperty; + }).call(exports, __webpack_require__(3)); +}, function(module, exports) { + "use strict"; + var ReactDOMComponentFlags = { + hasCachedChildNodes: 1 + }; + module.exports = ReactDOMComponentFlags; +}, function(module, exports, __webpack_require__) { + "use strict"; + function inject() { + alreadyInjected || (alreadyInjected = !0, ReactInjection.EventEmitter.injectReactEventListener(ReactEventListener), + ReactInjection.EventPluginHub.injectEventPluginOrder(DefaultEventPluginOrder), ReactInjection.EventPluginUtils.injectComponentTree(ReactDOMComponentTree), + ReactInjection.EventPluginUtils.injectTreeTraversal(ReactDOMTreeTraversal), ReactInjection.EventPluginHub.injectEventPluginsByName({ + SimpleEventPlugin: SimpleEventPlugin, + EnterLeaveEventPlugin: EnterLeaveEventPlugin, + ChangeEventPlugin: ChangeEventPlugin, + SelectEventPlugin: SelectEventPlugin, + BeforeInputEventPlugin: BeforeInputEventPlugin + }), ReactInjection.HostComponent.injectGenericComponentClass(ReactDOMComponent), + ReactInjection.HostComponent.injectTextComponentClass(ReactDOMTextComponent), ReactInjection.DOMProperty.injectDOMPropertyConfig(ARIADOMPropertyConfig), + ReactInjection.DOMProperty.injectDOMPropertyConfig(HTMLDOMPropertyConfig), ReactInjection.DOMProperty.injectDOMPropertyConfig(SVGDOMPropertyConfig), + ReactInjection.EmptyComponent.injectEmptyComponentFactory(function(instantiate) { + return new ReactDOMEmptyComponent(instantiate); + }), ReactInjection.Updates.injectReconcileTransaction(ReactReconcileTransaction), + ReactInjection.Updates.injectBatchingStrategy(ReactDefaultBatchingStrategy), ReactInjection.Component.injectEnvironment(ReactComponentBrowserEnvironment)); + } + var ARIADOMPropertyConfig = __webpack_require__(44), BeforeInputEventPlugin = __webpack_require__(45), ChangeEventPlugin = __webpack_require__(60), DefaultEventPluginOrder = __webpack_require__(78), EnterLeaveEventPlugin = __webpack_require__(79), HTMLDOMPropertyConfig = __webpack_require__(84), ReactComponentBrowserEnvironment = __webpack_require__(85), ReactDOMComponent = __webpack_require__(98), ReactDOMComponentTree = __webpack_require__(39), ReactDOMEmptyComponent = __webpack_require__(143), ReactDOMTreeTraversal = __webpack_require__(144), ReactDOMTextComponent = __webpack_require__(145), ReactDefaultBatchingStrategy = __webpack_require__(146), ReactEventListener = __webpack_require__(147), ReactInjection = __webpack_require__(150), ReactReconcileTransaction = __webpack_require__(151), SVGDOMPropertyConfig = __webpack_require__(159), SelectEventPlugin = __webpack_require__(160), SimpleEventPlugin = __webpack_require__(161), alreadyInjected = !1; + module.exports = { + inject: inject + }; +}, function(module, exports) { + "use strict"; + var ARIADOMPropertyConfig = { + Properties: { + "aria-current": 0, + "aria-details": 0, + "aria-disabled": 0, + "aria-hidden": 0, + "aria-invalid": 0, + "aria-keyshortcuts": 0, + "aria-label": 0, + "aria-roledescription": 0, + "aria-autocomplete": 0, + "aria-checked": 0, + "aria-expanded": 0, + "aria-haspopup": 0, + "aria-level": 0, + "aria-modal": 0, + "aria-multiline": 0, + "aria-multiselectable": 0, + "aria-orientation": 0, + "aria-placeholder": 0, + "aria-pressed": 0, + "aria-readonly": 0, + "aria-required": 0, + "aria-selected": 0, + "aria-sort": 0, + "aria-valuemax": 0, + "aria-valuemin": 0, + "aria-valuenow": 0, + "aria-valuetext": 0, + "aria-atomic": 0, + "aria-busy": 0, + "aria-live": 0, + "aria-relevant": 0, + "aria-dropeffect": 0, + "aria-grabbed": 0, + "aria-activedescendant": 0, + "aria-colcount": 0, + "aria-colindex": 0, + "aria-colspan": 0, + "aria-controls": 0, + "aria-describedby": 0, + "aria-errormessage": 0, + "aria-flowto": 0, + "aria-labelledby": 0, + "aria-owns": 0, + "aria-posinset": 0, + "aria-rowcount": 0, + "aria-rowindex": 0, + "aria-rowspan": 0, + "aria-setsize": 0 + }, + DOMAttributeNames: {}, + DOMPropertyNames: {} + }; + module.exports = ARIADOMPropertyConfig; +}, function(module, exports, __webpack_require__) { + "use strict"; + function isPresto() { + var opera = window.opera; + return "object" == typeof opera && "function" == typeof opera.version && parseInt(opera.version(), 10) <= 12; + } + function isKeypressCommand(nativeEvent) { + return (nativeEvent.ctrlKey || nativeEvent.altKey || nativeEvent.metaKey) && !(nativeEvent.ctrlKey && nativeEvent.altKey); + } + function getCompositionEventType(topLevelType) { + switch (topLevelType) { + case "topCompositionStart": + return eventTypes.compositionStart; + + case "topCompositionEnd": + return eventTypes.compositionEnd; + + case "topCompositionUpdate": + return eventTypes.compositionUpdate; + } + } + function isFallbackCompositionStart(topLevelType, nativeEvent) { + return "topKeyDown" === topLevelType && nativeEvent.keyCode === START_KEYCODE; + } + function isFallbackCompositionEnd(topLevelType, nativeEvent) { + switch (topLevelType) { + case "topKeyUp": + return END_KEYCODES.indexOf(nativeEvent.keyCode) !== -1; + + case "topKeyDown": + return nativeEvent.keyCode !== START_KEYCODE; + + case "topKeyPress": + case "topMouseDown": + case "topBlur": + return !0; + + default: + return !1; + } + } + function getDataFromCustomEvent(nativeEvent) { + var detail = nativeEvent.detail; + return "object" == typeof detail && "data" in detail ? detail.data : null; + } + function extractCompositionEvent(topLevelType, targetInst, nativeEvent, nativeEventTarget) { + var eventType, fallbackData; + if (canUseCompositionEvent ? eventType = getCompositionEventType(topLevelType) : currentComposition ? isFallbackCompositionEnd(topLevelType, nativeEvent) && (eventType = eventTypes.compositionEnd) : isFallbackCompositionStart(topLevelType, nativeEvent) && (eventType = eventTypes.compositionStart), + !eventType) return null; + useFallbackCompositionData && (currentComposition || eventType !== eventTypes.compositionStart ? eventType === eventTypes.compositionEnd && currentComposition && (fallbackData = currentComposition.getData()) : currentComposition = FallbackCompositionState.getPooled(nativeEventTarget)); + var event = SyntheticCompositionEvent.getPooled(eventType, targetInst, nativeEvent, nativeEventTarget); + if (fallbackData) event.data = fallbackData; else { + var customData = getDataFromCustomEvent(nativeEvent); + null !== customData && (event.data = customData); + } + return EventPropagators.accumulateTwoPhaseDispatches(event), event; + } + function getNativeBeforeInputChars(topLevelType, nativeEvent) { + switch (topLevelType) { + case "topCompositionEnd": + return getDataFromCustomEvent(nativeEvent); + + case "topKeyPress": + var which = nativeEvent.which; + return which !== SPACEBAR_CODE ? null : (hasSpaceKeypress = !0, SPACEBAR_CHAR); + + case "topTextInput": + var chars = nativeEvent.data; + return chars === SPACEBAR_CHAR && hasSpaceKeypress ? null : chars; + + default: + return null; + } + } + function getFallbackBeforeInputChars(topLevelType, nativeEvent) { + if (currentComposition) { + if ("topCompositionEnd" === topLevelType || !canUseCompositionEvent && isFallbackCompositionEnd(topLevelType, nativeEvent)) { + var chars = currentComposition.getData(); + return FallbackCompositionState.release(currentComposition), currentComposition = null, + chars; + } + return null; + } + switch (topLevelType) { + case "topPaste": + return null; + + case "topKeyPress": + return nativeEvent.which && !isKeypressCommand(nativeEvent) ? String.fromCharCode(nativeEvent.which) : null; + + case "topCompositionEnd": + return useFallbackCompositionData ? null : nativeEvent.data; + + default: + return null; + } + } + function extractBeforeInputEvent(topLevelType, targetInst, nativeEvent, nativeEventTarget) { + var chars; + if (chars = canUseTextInputEvent ? getNativeBeforeInputChars(topLevelType, nativeEvent) : getFallbackBeforeInputChars(topLevelType, nativeEvent), + !chars) return null; + var event = SyntheticInputEvent.getPooled(eventTypes.beforeInput, targetInst, nativeEvent, nativeEventTarget); + return event.data = chars, EventPropagators.accumulateTwoPhaseDispatches(event), + event; + } + var EventPropagators = __webpack_require__(46), ExecutionEnvironment = __webpack_require__(53), FallbackCompositionState = __webpack_require__(54), SyntheticCompositionEvent = __webpack_require__(57), SyntheticInputEvent = __webpack_require__(59), END_KEYCODES = [ 9, 13, 27, 32 ], START_KEYCODE = 229, canUseCompositionEvent = ExecutionEnvironment.canUseDOM && "CompositionEvent" in window, documentMode = null; + ExecutionEnvironment.canUseDOM && "documentMode" in document && (documentMode = document.documentMode); + var canUseTextInputEvent = ExecutionEnvironment.canUseDOM && "TextEvent" in window && !documentMode && !isPresto(), useFallbackCompositionData = ExecutionEnvironment.canUseDOM && (!canUseCompositionEvent || documentMode && documentMode > 8 && documentMode <= 11), SPACEBAR_CODE = 32, SPACEBAR_CHAR = String.fromCharCode(SPACEBAR_CODE), eventTypes = { + beforeInput: { + phasedRegistrationNames: { + bubbled: "onBeforeInput", + captured: "onBeforeInputCapture" + }, + dependencies: [ "topCompositionEnd", "topKeyPress", "topTextInput", "topPaste" ] + }, + compositionEnd: { + phasedRegistrationNames: { + bubbled: "onCompositionEnd", + captured: "onCompositionEndCapture" + }, + dependencies: [ "topBlur", "topCompositionEnd", "topKeyDown", "topKeyPress", "topKeyUp", "topMouseDown" ] + }, + compositionStart: { + phasedRegistrationNames: { + bubbled: "onCompositionStart", + captured: "onCompositionStartCapture" + }, + dependencies: [ "topBlur", "topCompositionStart", "topKeyDown", "topKeyPress", "topKeyUp", "topMouseDown" ] + }, + compositionUpdate: { + phasedRegistrationNames: { + bubbled: "onCompositionUpdate", + captured: "onCompositionUpdateCapture" + }, + dependencies: [ "topBlur", "topCompositionUpdate", "topKeyDown", "topKeyPress", "topKeyUp", "topMouseDown" ] + } + }, hasSpaceKeypress = !1, currentComposition = null, BeforeInputEventPlugin = { + eventTypes: eventTypes, + extractEvents: function(topLevelType, targetInst, nativeEvent, nativeEventTarget) { + return [ extractCompositionEvent(topLevelType, targetInst, nativeEvent, nativeEventTarget), extractBeforeInputEvent(topLevelType, targetInst, nativeEvent, nativeEventTarget) ]; + } + }; + module.exports = BeforeInputEventPlugin; +}, function(module, exports, __webpack_require__) { + (function(process) { + "use strict"; + function listenerAtPhase(inst, event, propagationPhase) { + var registrationName = event.dispatchConfig.phasedRegistrationNames[propagationPhase]; + return getListener(inst, registrationName); + } + function accumulateDirectionalDispatches(inst, phase, event) { + "production" !== process.env.NODE_ENV && ("production" !== process.env.NODE_ENV ? warning(inst, "Dispatching inst must not be null") : void 0); + var listener = listenerAtPhase(inst, event, phase); + listener && (event._dispatchListeners = accumulateInto(event._dispatchListeners, listener), + event._dispatchInstances = accumulateInto(event._dispatchInstances, inst)); + } + function accumulateTwoPhaseDispatchesSingle(event) { + event && event.dispatchConfig.phasedRegistrationNames && EventPluginUtils.traverseTwoPhase(event._targetInst, accumulateDirectionalDispatches, event); + } + function accumulateTwoPhaseDispatchesSingleSkipTarget(event) { + if (event && event.dispatchConfig.phasedRegistrationNames) { + var targetInst = event._targetInst, parentInst = targetInst ? EventPluginUtils.getParentInstance(targetInst) : null; + EventPluginUtils.traverseTwoPhase(parentInst, accumulateDirectionalDispatches, event); + } + } + function accumulateDispatches(inst, ignoredDirection, event) { + if (event && event.dispatchConfig.registrationName) { + var registrationName = event.dispatchConfig.registrationName, listener = getListener(inst, registrationName); + listener && (event._dispatchListeners = accumulateInto(event._dispatchListeners, listener), + event._dispatchInstances = accumulateInto(event._dispatchInstances, inst)); + } + } + function accumulateDirectDispatchesSingle(event) { + event && event.dispatchConfig.registrationName && accumulateDispatches(event._targetInst, null, event); + } + function accumulateTwoPhaseDispatches(events) { + forEachAccumulated(events, accumulateTwoPhaseDispatchesSingle); + } + function accumulateTwoPhaseDispatchesSkipTarget(events) { + forEachAccumulated(events, accumulateTwoPhaseDispatchesSingleSkipTarget); + } + function accumulateEnterLeaveDispatches(leave, enter, from, to) { + EventPluginUtils.traverseEnterLeave(from, to, accumulateDispatches, leave, enter); + } + function accumulateDirectDispatches(events) { + forEachAccumulated(events, accumulateDirectDispatchesSingle); + } + var EventPluginHub = __webpack_require__(47), EventPluginUtils = __webpack_require__(49), accumulateInto = __webpack_require__(51), forEachAccumulated = __webpack_require__(52), warning = __webpack_require__(8), getListener = EventPluginHub.getListener, EventPropagators = { + accumulateTwoPhaseDispatches: accumulateTwoPhaseDispatches, + accumulateTwoPhaseDispatchesSkipTarget: accumulateTwoPhaseDispatchesSkipTarget, + accumulateDirectDispatches: accumulateDirectDispatches, + accumulateEnterLeaveDispatches: accumulateEnterLeaveDispatches + }; + module.exports = EventPropagators; + }).call(exports, __webpack_require__(3)); +}, function(module, exports, __webpack_require__) { + (function(process) { + "use strict"; + function isInteractive(tag) { + return "button" === tag || "input" === tag || "select" === tag || "textarea" === tag; + } + function shouldPreventMouseEvent(name, type, props) { + switch (name) { + case "onClick": + case "onClickCapture": + case "onDoubleClick": + case "onDoubleClickCapture": + case "onMouseDown": + case "onMouseDownCapture": + case "onMouseMove": + case "onMouseMoveCapture": + case "onMouseUp": + case "onMouseUpCapture": + return !(!props.disabled || !isInteractive(type)); + + default: + return !1; + } + } + var _prodInvariant = __webpack_require__(40), EventPluginRegistry = __webpack_require__(48), EventPluginUtils = __webpack_require__(49), ReactErrorUtils = __webpack_require__(50), accumulateInto = __webpack_require__(51), forEachAccumulated = __webpack_require__(52), invariant = __webpack_require__(12), listenerBank = {}, eventQueue = null, executeDispatchesAndRelease = function(event, simulated) { + event && (EventPluginUtils.executeDispatchesInOrder(event, simulated), event.isPersistent() || event.constructor.release(event)); + }, executeDispatchesAndReleaseSimulated = function(e) { + return executeDispatchesAndRelease(e, !0); + }, executeDispatchesAndReleaseTopLevel = function(e) { + return executeDispatchesAndRelease(e, !1); + }, getDictionaryKey = function(inst) { + return "." + inst._rootNodeID; + }, EventPluginHub = { + injection: { + injectEventPluginOrder: EventPluginRegistry.injectEventPluginOrder, + injectEventPluginsByName: EventPluginRegistry.injectEventPluginsByName + }, + putListener: function(inst, registrationName, listener) { + "function" != typeof listener ? "production" !== process.env.NODE_ENV ? invariant(!1, "Expected %s listener to be a function, instead got type %s", registrationName, typeof listener) : _prodInvariant("94", registrationName, typeof listener) : void 0; + var key = getDictionaryKey(inst), bankForRegistrationName = listenerBank[registrationName] || (listenerBank[registrationName] = {}); + bankForRegistrationName[key] = listener; + var PluginModule = EventPluginRegistry.registrationNameModules[registrationName]; + PluginModule && PluginModule.didPutListener && PluginModule.didPutListener(inst, registrationName, listener); + }, + getListener: function(inst, registrationName) { + var bankForRegistrationName = listenerBank[registrationName]; + if (shouldPreventMouseEvent(registrationName, inst._currentElement.type, inst._currentElement.props)) return null; + var key = getDictionaryKey(inst); + return bankForRegistrationName && bankForRegistrationName[key]; + }, + deleteListener: function(inst, registrationName) { + var PluginModule = EventPluginRegistry.registrationNameModules[registrationName]; + PluginModule && PluginModule.willDeleteListener && PluginModule.willDeleteListener(inst, registrationName); + var bankForRegistrationName = listenerBank[registrationName]; + if (bankForRegistrationName) { + var key = getDictionaryKey(inst); + delete bankForRegistrationName[key]; + } + }, + deleteAllListeners: function(inst) { + var key = getDictionaryKey(inst); + for (var registrationName in listenerBank) if (listenerBank.hasOwnProperty(registrationName) && listenerBank[registrationName][key]) { + var PluginModule = EventPluginRegistry.registrationNameModules[registrationName]; + PluginModule && PluginModule.willDeleteListener && PluginModule.willDeleteListener(inst, registrationName), + delete listenerBank[registrationName][key]; + } + }, + extractEvents: function(topLevelType, targetInst, nativeEvent, nativeEventTarget) { + for (var events, plugins = EventPluginRegistry.plugins, i = 0; i < plugins.length; i++) { + var possiblePlugin = plugins[i]; + if (possiblePlugin) { + var extractedEvents = possiblePlugin.extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget); + extractedEvents && (events = accumulateInto(events, extractedEvents)); + } + } + return events; + }, + enqueueEvents: function(events) { + events && (eventQueue = accumulateInto(eventQueue, events)); + }, + processEventQueue: function(simulated) { + var processingEventQueue = eventQueue; + eventQueue = null, simulated ? forEachAccumulated(processingEventQueue, executeDispatchesAndReleaseSimulated) : forEachAccumulated(processingEventQueue, executeDispatchesAndReleaseTopLevel), + eventQueue ? "production" !== process.env.NODE_ENV ? invariant(!1, "processEventQueue(): Additional events were enqueued while processing an event queue. Support for this has not yet been implemented.") : _prodInvariant("95") : void 0, + ReactErrorUtils.rethrowCaughtError(); + }, + __purge: function() { + listenerBank = {}; + }, + __getListenerBank: function() { + return listenerBank; + } + }; + module.exports = EventPluginHub; + }).call(exports, __webpack_require__(3)); +}, function(module, exports, __webpack_require__) { + (function(process) { + "use strict"; + function recomputePluginOrdering() { + if (eventPluginOrder) for (var pluginName in namesToPlugins) { + var pluginModule = namesToPlugins[pluginName], pluginIndex = eventPluginOrder.indexOf(pluginName); + if (pluginIndex > -1 ? void 0 : "production" !== process.env.NODE_ENV ? invariant(!1, "EventPluginRegistry: Cannot inject event plugins that do not exist in the plugin ordering, `%s`.", pluginName) : _prodInvariant("96", pluginName), + !EventPluginRegistry.plugins[pluginIndex]) { + pluginModule.extractEvents ? void 0 : "production" !== process.env.NODE_ENV ? invariant(!1, "EventPluginRegistry: Event plugins must implement an `extractEvents` method, but `%s` does not.", pluginName) : _prodInvariant("97", pluginName), + EventPluginRegistry.plugins[pluginIndex] = pluginModule; + var publishedEvents = pluginModule.eventTypes; + for (var eventName in publishedEvents) publishEventForPlugin(publishedEvents[eventName], pluginModule, eventName) ? void 0 : "production" !== process.env.NODE_ENV ? invariant(!1, "EventPluginRegistry: Failed to publish event `%s` for plugin `%s`.", eventName, pluginName) : _prodInvariant("98", eventName, pluginName); + } + } + } + function publishEventForPlugin(dispatchConfig, pluginModule, eventName) { + EventPluginRegistry.eventNameDispatchConfigs.hasOwnProperty(eventName) ? "production" !== process.env.NODE_ENV ? invariant(!1, "EventPluginHub: More than one plugin attempted to publish the same event name, `%s`.", eventName) : _prodInvariant("99", eventName) : void 0, + EventPluginRegistry.eventNameDispatchConfigs[eventName] = dispatchConfig; + var phasedRegistrationNames = dispatchConfig.phasedRegistrationNames; + if (phasedRegistrationNames) { + for (var phaseName in phasedRegistrationNames) if (phasedRegistrationNames.hasOwnProperty(phaseName)) { + var phasedRegistrationName = phasedRegistrationNames[phaseName]; + publishRegistrationName(phasedRegistrationName, pluginModule, eventName); + } + return !0; + } + return !!dispatchConfig.registrationName && (publishRegistrationName(dispatchConfig.registrationName, pluginModule, eventName), + !0); + } + function publishRegistrationName(registrationName, pluginModule, eventName) { + if (EventPluginRegistry.registrationNameModules[registrationName] ? "production" !== process.env.NODE_ENV ? invariant(!1, "EventPluginHub: More than one plugin attempted to publish the same registration name, `%s`.", registrationName) : _prodInvariant("100", registrationName) : void 0, + EventPluginRegistry.registrationNameModules[registrationName] = pluginModule, EventPluginRegistry.registrationNameDependencies[registrationName] = pluginModule.eventTypes[eventName].dependencies, + "production" !== process.env.NODE_ENV) { + var lowerCasedName = registrationName.toLowerCase(); + EventPluginRegistry.possibleRegistrationNames[lowerCasedName] = registrationName, + "onDoubleClick" === registrationName && (EventPluginRegistry.possibleRegistrationNames.ondblclick = registrationName); + } + } + var _prodInvariant = __webpack_require__(40), invariant = __webpack_require__(12), eventPluginOrder = null, namesToPlugins = {}, EventPluginRegistry = { + plugins: [], + eventNameDispatchConfigs: {}, + registrationNameModules: {}, + registrationNameDependencies: {}, + possibleRegistrationNames: "production" !== process.env.NODE_ENV ? {} : null, + injectEventPluginOrder: function(injectedEventPluginOrder) { + eventPluginOrder ? "production" !== process.env.NODE_ENV ? invariant(!1, "EventPluginRegistry: Cannot inject event plugin ordering more than once. You are likely trying to load more than one copy of React.") : _prodInvariant("101") : void 0, + eventPluginOrder = Array.prototype.slice.call(injectedEventPluginOrder), recomputePluginOrdering(); + }, + injectEventPluginsByName: function(injectedNamesToPlugins) { + var isOrderingDirty = !1; + for (var pluginName in injectedNamesToPlugins) if (injectedNamesToPlugins.hasOwnProperty(pluginName)) { + var pluginModule = injectedNamesToPlugins[pluginName]; + namesToPlugins.hasOwnProperty(pluginName) && namesToPlugins[pluginName] === pluginModule || (namesToPlugins[pluginName] ? "production" !== process.env.NODE_ENV ? invariant(!1, "EventPluginRegistry: Cannot inject two different event plugins using the same name, `%s`.", pluginName) : _prodInvariant("102", pluginName) : void 0, + namesToPlugins[pluginName] = pluginModule, isOrderingDirty = !0); + } + isOrderingDirty && recomputePluginOrdering(); + }, + getPluginModuleForEvent: function(event) { + var dispatchConfig = event.dispatchConfig; + if (dispatchConfig.registrationName) return EventPluginRegistry.registrationNameModules[dispatchConfig.registrationName] || null; + if (void 0 !== dispatchConfig.phasedRegistrationNames) { + var phasedRegistrationNames = dispatchConfig.phasedRegistrationNames; + for (var phase in phasedRegistrationNames) if (phasedRegistrationNames.hasOwnProperty(phase)) { + var pluginModule = EventPluginRegistry.registrationNameModules[phasedRegistrationNames[phase]]; + if (pluginModule) return pluginModule; + } + } + return null; + }, + _resetEventPlugins: function() { + eventPluginOrder = null; + for (var pluginName in namesToPlugins) namesToPlugins.hasOwnProperty(pluginName) && delete namesToPlugins[pluginName]; + EventPluginRegistry.plugins.length = 0; + var eventNameDispatchConfigs = EventPluginRegistry.eventNameDispatchConfigs; + for (var eventName in eventNameDispatchConfigs) eventNameDispatchConfigs.hasOwnProperty(eventName) && delete eventNameDispatchConfigs[eventName]; + var registrationNameModules = EventPluginRegistry.registrationNameModules; + for (var registrationName in registrationNameModules) registrationNameModules.hasOwnProperty(registrationName) && delete registrationNameModules[registrationName]; + if ("production" !== process.env.NODE_ENV) { + var possibleRegistrationNames = EventPluginRegistry.possibleRegistrationNames; + for (var lowerCasedName in possibleRegistrationNames) possibleRegistrationNames.hasOwnProperty(lowerCasedName) && delete possibleRegistrationNames[lowerCasedName]; + } + } + }; + module.exports = EventPluginRegistry; + }).call(exports, __webpack_require__(3)); +}, function(module, exports, __webpack_require__) { + (function(process) { + "use strict"; + function isEndish(topLevelType) { + return "topMouseUp" === topLevelType || "topTouchEnd" === topLevelType || "topTouchCancel" === topLevelType; + } + function isMoveish(topLevelType) { + return "topMouseMove" === topLevelType || "topTouchMove" === topLevelType; + } + function isStartish(topLevelType) { + return "topMouseDown" === topLevelType || "topTouchStart" === topLevelType; + } + function executeDispatch(event, simulated, listener, inst) { + var type = event.type || "unknown-event"; + event.currentTarget = EventPluginUtils.getNodeFromInstance(inst), simulated ? ReactErrorUtils.invokeGuardedCallbackWithCatch(type, listener, event) : ReactErrorUtils.invokeGuardedCallback(type, listener, event), + event.currentTarget = null; + } + function executeDispatchesInOrder(event, simulated) { + var dispatchListeners = event._dispatchListeners, dispatchInstances = event._dispatchInstances; + if ("production" !== process.env.NODE_ENV && validateEventDispatches(event), Array.isArray(dispatchListeners)) for (var i = 0; i < dispatchListeners.length && !event.isPropagationStopped(); i++) executeDispatch(event, simulated, dispatchListeners[i], dispatchInstances[i]); else dispatchListeners && executeDispatch(event, simulated, dispatchListeners, dispatchInstances); + event._dispatchListeners = null, event._dispatchInstances = null; + } + function executeDispatchesInOrderStopAtTrueImpl(event) { + var dispatchListeners = event._dispatchListeners, dispatchInstances = event._dispatchInstances; + if ("production" !== process.env.NODE_ENV && validateEventDispatches(event), Array.isArray(dispatchListeners)) { + for (var i = 0; i < dispatchListeners.length && !event.isPropagationStopped(); i++) if (dispatchListeners[i](event, dispatchInstances[i])) return dispatchInstances[i]; + } else if (dispatchListeners && dispatchListeners(event, dispatchInstances)) return dispatchInstances; + return null; + } + function executeDispatchesInOrderStopAtTrue(event) { + var ret = executeDispatchesInOrderStopAtTrueImpl(event); + return event._dispatchInstances = null, event._dispatchListeners = null, ret; + } + function executeDirectDispatch(event) { + "production" !== process.env.NODE_ENV && validateEventDispatches(event); + var dispatchListener = event._dispatchListeners, dispatchInstance = event._dispatchInstances; + Array.isArray(dispatchListener) ? "production" !== process.env.NODE_ENV ? invariant(!1, "executeDirectDispatch(...): Invalid `event`.") : _prodInvariant("103") : void 0, + event.currentTarget = dispatchListener ? EventPluginUtils.getNodeFromInstance(dispatchInstance) : null; + var res = dispatchListener ? dispatchListener(event) : null; + return event.currentTarget = null, event._dispatchListeners = null, event._dispatchInstances = null, + res; + } + function hasDispatches(event) { + return !!event._dispatchListeners; + } + var ComponentTree, TreeTraversal, validateEventDispatches, _prodInvariant = __webpack_require__(40), ReactErrorUtils = __webpack_require__(50), invariant = __webpack_require__(12), warning = __webpack_require__(8), injection = { + injectComponentTree: function(Injected) { + ComponentTree = Injected, "production" !== process.env.NODE_ENV && ("production" !== process.env.NODE_ENV ? warning(Injected && Injected.getNodeFromInstance && Injected.getInstanceFromNode, "EventPluginUtils.injection.injectComponentTree(...): Injected module is missing getNodeFromInstance or getInstanceFromNode.") : void 0); + }, + injectTreeTraversal: function(Injected) { + TreeTraversal = Injected, "production" !== process.env.NODE_ENV && ("production" !== process.env.NODE_ENV ? warning(Injected && Injected.isAncestor && Injected.getLowestCommonAncestor, "EventPluginUtils.injection.injectTreeTraversal(...): Injected module is missing isAncestor or getLowestCommonAncestor.") : void 0); + } + }; + "production" !== process.env.NODE_ENV && (validateEventDispatches = function(event) { + var dispatchListeners = event._dispatchListeners, dispatchInstances = event._dispatchInstances, listenersIsArr = Array.isArray(dispatchListeners), listenersLen = listenersIsArr ? dispatchListeners.length : dispatchListeners ? 1 : 0, instancesIsArr = Array.isArray(dispatchInstances), instancesLen = instancesIsArr ? dispatchInstances.length : dispatchInstances ? 1 : 0; + "production" !== process.env.NODE_ENV ? warning(instancesIsArr === listenersIsArr && instancesLen === listenersLen, "EventPluginUtils: Invalid `event`.") : void 0; + }); + var EventPluginUtils = { + isEndish: isEndish, + isMoveish: isMoveish, + isStartish: isStartish, + executeDirectDispatch: executeDirectDispatch, + executeDispatchesInOrder: executeDispatchesInOrder, + executeDispatchesInOrderStopAtTrue: executeDispatchesInOrderStopAtTrue, + hasDispatches: hasDispatches, + getInstanceFromNode: function(node) { + return ComponentTree.getInstanceFromNode(node); + }, + getNodeFromInstance: function(node) { + return ComponentTree.getNodeFromInstance(node); + }, + isAncestor: function(a, b) { + return TreeTraversal.isAncestor(a, b); + }, + getLowestCommonAncestor: function(a, b) { + return TreeTraversal.getLowestCommonAncestor(a, b); + }, + getParentInstance: function(inst) { + return TreeTraversal.getParentInstance(inst); + }, + traverseTwoPhase: function(target, fn, arg) { + return TreeTraversal.traverseTwoPhase(target, fn, arg); + }, + traverseEnterLeave: function(from, to, fn, argFrom, argTo) { + return TreeTraversal.traverseEnterLeave(from, to, fn, argFrom, argTo); + }, + injection: injection + }; + module.exports = EventPluginUtils; + }).call(exports, __webpack_require__(3)); +}, function(module, exports, __webpack_require__) { + (function(process) { + "use strict"; + function invokeGuardedCallback(name, func, a) { + try { + func(a); + } catch (x) { + null === caughtError && (caughtError = x); + } + } + var caughtError = null, ReactErrorUtils = { + invokeGuardedCallback: invokeGuardedCallback, + invokeGuardedCallbackWithCatch: invokeGuardedCallback, + rethrowCaughtError: function() { + if (caughtError) { + var error = caughtError; + throw caughtError = null, error; + } + } + }; + if ("production" !== process.env.NODE_ENV && "undefined" != typeof window && "function" == typeof window.dispatchEvent && "undefined" != typeof document && "function" == typeof document.createEvent) { + var fakeNode = document.createElement("react"); + ReactErrorUtils.invokeGuardedCallback = function(name, func, a) { + var boundFunc = func.bind(null, a), evtType = "react-" + name; + fakeNode.addEventListener(evtType, boundFunc, !1); + var evt = document.createEvent("Event"); + evt.initEvent(evtType, !1, !1), fakeNode.dispatchEvent(evt), fakeNode.removeEventListener(evtType, boundFunc, !1); + }; + } + module.exports = ReactErrorUtils; + }).call(exports, __webpack_require__(3)); +}, function(module, exports, __webpack_require__) { + (function(process) { + "use strict"; + function accumulateInto(current, next) { + return null == next ? "production" !== process.env.NODE_ENV ? invariant(!1, "accumulateInto(...): Accumulated items must not be null or undefined.") : _prodInvariant("30") : void 0, + null == current ? next : Array.isArray(current) ? Array.isArray(next) ? (current.push.apply(current, next), + current) : (current.push(next), current) : Array.isArray(next) ? [ current ].concat(next) : [ current, next ]; + } + var _prodInvariant = __webpack_require__(40), invariant = __webpack_require__(12); + module.exports = accumulateInto; + }).call(exports, __webpack_require__(3)); +}, function(module, exports) { + "use strict"; + function forEachAccumulated(arr, cb, scope) { + Array.isArray(arr) ? arr.forEach(cb, scope) : arr && cb.call(scope, arr); + } + module.exports = forEachAccumulated; +}, function(module, exports) { + "use strict"; + var canUseDOM = !("undefined" == typeof window || !window.document || !window.document.createElement), ExecutionEnvironment = { + canUseDOM: canUseDOM, + canUseWorkers: "undefined" != typeof Worker, + canUseEventListeners: canUseDOM && !(!window.addEventListener && !window.attachEvent), + canUseViewport: canUseDOM && !!window.screen, + isInWorker: !canUseDOM + }; + module.exports = ExecutionEnvironment; +}, function(module, exports, __webpack_require__) { + "use strict"; + function FallbackCompositionState(root) { + this._root = root, this._startText = this.getText(), this._fallbackText = null; + } + var _assign = __webpack_require__(4), PooledClass = __webpack_require__(55), getTextContentAccessor = __webpack_require__(56); + _assign(FallbackCompositionState.prototype, { + destructor: function() { + this._root = null, this._startText = null, this._fallbackText = null; + }, + getText: function() { + return "value" in this._root ? this._root.value : this._root[getTextContentAccessor()]; + }, + getData: function() { + if (this._fallbackText) return this._fallbackText; + var start, end, startValue = this._startText, startLength = startValue.length, endValue = this.getText(), endLength = endValue.length; + for (start = 0; start < startLength && startValue[start] === endValue[start]; start++) ; + var minEnd = startLength - start; + for (end = 1; end <= minEnd && startValue[startLength - end] === endValue[endLength - end]; end++) ; + var sliceTail = end > 1 ? 1 - end : void 0; + return this._fallbackText = endValue.slice(start, sliceTail), this._fallbackText; + } + }), PooledClass.addPoolingTo(FallbackCompositionState), module.exports = FallbackCompositionState; +}, function(module, exports, __webpack_require__) { + (function(process) { + "use strict"; + var _prodInvariant = __webpack_require__(40), invariant = __webpack_require__(12), oneArgumentPooler = function(copyFieldsFrom) { + var Klass = this; + if (Klass.instancePool.length) { + var instance = Klass.instancePool.pop(); + return Klass.call(instance, copyFieldsFrom), instance; + } + return new Klass(copyFieldsFrom); + }, twoArgumentPooler = function(a1, a2) { + var Klass = this; + if (Klass.instancePool.length) { + var instance = Klass.instancePool.pop(); + return Klass.call(instance, a1, a2), instance; + } + return new Klass(a1, a2); + }, threeArgumentPooler = function(a1, a2, a3) { + var Klass = this; + if (Klass.instancePool.length) { + var instance = Klass.instancePool.pop(); + return Klass.call(instance, a1, a2, a3), instance; + } + return new Klass(a1, a2, a3); + }, fourArgumentPooler = function(a1, a2, a3, a4) { + var Klass = this; + if (Klass.instancePool.length) { + var instance = Klass.instancePool.pop(); + return Klass.call(instance, a1, a2, a3, a4), instance; + } + return new Klass(a1, a2, a3, a4); + }, standardReleaser = function(instance) { + var Klass = this; + instance instanceof Klass ? void 0 : "production" !== process.env.NODE_ENV ? invariant(!1, "Trying to release an instance into a pool of a different type.") : _prodInvariant("25"), + instance.destructor(), Klass.instancePool.length < Klass.poolSize && Klass.instancePool.push(instance); + }, DEFAULT_POOL_SIZE = 10, DEFAULT_POOLER = oneArgumentPooler, addPoolingTo = function(CopyConstructor, pooler) { + var NewKlass = CopyConstructor; + return NewKlass.instancePool = [], NewKlass.getPooled = pooler || DEFAULT_POOLER, + NewKlass.poolSize || (NewKlass.poolSize = DEFAULT_POOL_SIZE), NewKlass.release = standardReleaser, + NewKlass; + }, PooledClass = { + addPoolingTo: addPoolingTo, + oneArgumentPooler: oneArgumentPooler, + twoArgumentPooler: twoArgumentPooler, + threeArgumentPooler: threeArgumentPooler, + fourArgumentPooler: fourArgumentPooler + }; + module.exports = PooledClass; + }).call(exports, __webpack_require__(3)); +}, function(module, exports, __webpack_require__) { + "use strict"; + function getTextContentAccessor() { + return !contentKey && ExecutionEnvironment.canUseDOM && (contentKey = "textContent" in document.documentElement ? "textContent" : "innerText"), + contentKey; + } + var ExecutionEnvironment = __webpack_require__(53), contentKey = null; + module.exports = getTextContentAccessor; +}, function(module, exports, __webpack_require__) { + "use strict"; + function SyntheticCompositionEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) { + return SyntheticEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget); + } + var SyntheticEvent = __webpack_require__(58), CompositionEventInterface = { + data: null + }; + SyntheticEvent.augmentClass(SyntheticCompositionEvent, CompositionEventInterface), + module.exports = SyntheticCompositionEvent; +}, function(module, exports, __webpack_require__) { + (function(process) { + "use strict"; + function SyntheticEvent(dispatchConfig, targetInst, nativeEvent, nativeEventTarget) { + "production" !== process.env.NODE_ENV && (delete this.nativeEvent, delete this.preventDefault, + delete this.stopPropagation), this.dispatchConfig = dispatchConfig, this._targetInst = targetInst, + this.nativeEvent = nativeEvent; + var Interface = this.constructor.Interface; + for (var propName in Interface) if (Interface.hasOwnProperty(propName)) { + "production" !== process.env.NODE_ENV && delete this[propName]; + var normalize = Interface[propName]; + normalize ? this[propName] = normalize(nativeEvent) : "target" === propName ? this.target = nativeEventTarget : this[propName] = nativeEvent[propName]; + } + var defaultPrevented = null != nativeEvent.defaultPrevented ? nativeEvent.defaultPrevented : nativeEvent.returnValue === !1; + return defaultPrevented ? this.isDefaultPrevented = emptyFunction.thatReturnsTrue : this.isDefaultPrevented = emptyFunction.thatReturnsFalse, + this.isPropagationStopped = emptyFunction.thatReturnsFalse, this; + } + function getPooledWarningPropertyDefinition(propName, getVal) { + function set(val) { + var action = isFunction ? "setting the method" : "setting the property"; + return warn(action, "This is effectively a no-op"), val; + } + function get() { + var action = isFunction ? "accessing the method" : "accessing the property", result = isFunction ? "This is a no-op function" : "This is set to null"; + return warn(action, result), getVal; + } + function warn(action, result) { + var warningCondition = !1; + "production" !== process.env.NODE_ENV ? warning(warningCondition, "This synthetic event is reused for performance reasons. If you're seeing this, you're %s `%s` on a released/nullified synthetic event. %s. If you must keep the original synthetic event around, use event.persist(). See https://fb.me/react-event-pooling for more information.", action, propName, result) : void 0; + } + var isFunction = "function" == typeof getVal; + return { + configurable: !0, + set: set, + get: get + }; + } + var _assign = __webpack_require__(4), PooledClass = __webpack_require__(55), emptyFunction = __webpack_require__(9), warning = __webpack_require__(8), didWarnForAddedNewProperty = !1, isProxySupported = "function" == typeof Proxy, shouldBeReleasedProperties = [ "dispatchConfig", "_targetInst", "nativeEvent", "isDefaultPrevented", "isPropagationStopped", "_dispatchListeners", "_dispatchInstances" ], EventInterface = { + type: null, + target: null, + currentTarget: emptyFunction.thatReturnsNull, + eventPhase: null, + bubbles: null, + cancelable: null, + timeStamp: function(event) { + return event.timeStamp || Date.now(); + }, + defaultPrevented: null, + isTrusted: null + }; + _assign(SyntheticEvent.prototype, { + preventDefault: function() { + this.defaultPrevented = !0; + var event = this.nativeEvent; + event && (event.preventDefault ? event.preventDefault() : "unknown" != typeof event.returnValue && (event.returnValue = !1), + this.isDefaultPrevented = emptyFunction.thatReturnsTrue); + }, + stopPropagation: function() { + var event = this.nativeEvent; + event && (event.stopPropagation ? event.stopPropagation() : "unknown" != typeof event.cancelBubble && (event.cancelBubble = !0), + this.isPropagationStopped = emptyFunction.thatReturnsTrue); + }, + persist: function() { + this.isPersistent = emptyFunction.thatReturnsTrue; + }, + isPersistent: emptyFunction.thatReturnsFalse, + destructor: function() { + var Interface = this.constructor.Interface; + for (var propName in Interface) "production" !== process.env.NODE_ENV ? Object.defineProperty(this, propName, getPooledWarningPropertyDefinition(propName, Interface[propName])) : this[propName] = null; + for (var i = 0; i < shouldBeReleasedProperties.length; i++) this[shouldBeReleasedProperties[i]] = null; + "production" !== process.env.NODE_ENV && (Object.defineProperty(this, "nativeEvent", getPooledWarningPropertyDefinition("nativeEvent", null)), + Object.defineProperty(this, "preventDefault", getPooledWarningPropertyDefinition("preventDefault", emptyFunction)), + Object.defineProperty(this, "stopPropagation", getPooledWarningPropertyDefinition("stopPropagation", emptyFunction))); + } + }), SyntheticEvent.Interface = EventInterface, "production" !== process.env.NODE_ENV && isProxySupported && (SyntheticEvent = new Proxy(SyntheticEvent, { + construct: function(target, args) { + return this.apply(target, Object.create(target.prototype), args); + }, + apply: function(constructor, that, args) { + return new Proxy(constructor.apply(that, args), { + set: function(target, prop, value) { + return "isPersistent" === prop || target.constructor.Interface.hasOwnProperty(prop) || shouldBeReleasedProperties.indexOf(prop) !== -1 || ("production" !== process.env.NODE_ENV ? warning(didWarnForAddedNewProperty || target.isPersistent(), "This synthetic event is reused for performance reasons. If you're seeing this, you're adding a new property in the synthetic event object. The property is never released. See https://fb.me/react-event-pooling for more information.") : void 0, + didWarnForAddedNewProperty = !0), target[prop] = value, !0; + } + }); + } + })), SyntheticEvent.augmentClass = function(Class, Interface) { + var Super = this, E = function() {}; + E.prototype = Super.prototype; + var prototype = new E(); + _assign(prototype, Class.prototype), Class.prototype = prototype, Class.prototype.constructor = Class, + Class.Interface = _assign({}, Super.Interface, Interface), Class.augmentClass = Super.augmentClass, + PooledClass.addPoolingTo(Class, PooledClass.fourArgumentPooler); + }, PooledClass.addPoolingTo(SyntheticEvent, PooledClass.fourArgumentPooler), module.exports = SyntheticEvent; + }).call(exports, __webpack_require__(3)); +}, function(module, exports, __webpack_require__) { + "use strict"; + function SyntheticInputEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) { + return SyntheticEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget); + } + var SyntheticEvent = __webpack_require__(58), InputEventInterface = { + data: null + }; + SyntheticEvent.augmentClass(SyntheticInputEvent, InputEventInterface), module.exports = SyntheticInputEvent; +}, function(module, exports, __webpack_require__) { + "use strict"; + function createAndAccumulateChangeEvent(inst, nativeEvent, target) { + var event = SyntheticEvent.getPooled(eventTypes.change, inst, nativeEvent, target); + return event.type = "change", EventPropagators.accumulateTwoPhaseDispatches(event), + event; + } + function shouldUseChangeEvent(elem) { + var nodeName = elem.nodeName && elem.nodeName.toLowerCase(); + return "select" === nodeName || "input" === nodeName && "file" === elem.type; + } + function manualDispatchChangeEvent(nativeEvent) { + var event = createAndAccumulateChangeEvent(activeElementInst, nativeEvent, getEventTarget(nativeEvent)); + ReactUpdates.batchedUpdates(runEventInBatch, event); + } + function runEventInBatch(event) { + EventPluginHub.enqueueEvents(event), EventPluginHub.processEventQueue(!1); + } + function startWatchingForChangeEventIE8(target, targetInst) { + activeElement = target, activeElementInst = targetInst, activeElement.attachEvent("onchange", manualDispatchChangeEvent); + } + function stopWatchingForChangeEventIE8() { + activeElement && (activeElement.detachEvent("onchange", manualDispatchChangeEvent), + activeElement = null, activeElementInst = null); + } + function getInstIfValueChanged(targetInst, nativeEvent) { + var updated = inputValueTracking.updateValueIfChanged(targetInst), simulated = nativeEvent.simulated === !0 && ChangeEventPlugin._allowSimulatedPassThrough; + if (updated || simulated) return targetInst; + } + function getTargetInstForChangeEvent(topLevelType, targetInst) { + if ("topChange" === topLevelType) return targetInst; + } + function handleEventsForChangeEventIE8(topLevelType, target, targetInst) { + "topFocus" === topLevelType ? (stopWatchingForChangeEventIE8(), startWatchingForChangeEventIE8(target, targetInst)) : "topBlur" === topLevelType && stopWatchingForChangeEventIE8(); + } + function startWatchingForValueChange(target, targetInst) { + activeElement = target, activeElementInst = targetInst, activeElement.attachEvent("onpropertychange", handlePropertyChange); + } + function stopWatchingForValueChange() { + activeElement && (activeElement.detachEvent("onpropertychange", handlePropertyChange), + activeElement = null, activeElementInst = null); + } + function handlePropertyChange(nativeEvent) { + "value" === nativeEvent.propertyName && getInstIfValueChanged(activeElementInst, nativeEvent) && manualDispatchChangeEvent(nativeEvent); + } + function handleEventsForInputEventPolyfill(topLevelType, target, targetInst) { + "topFocus" === topLevelType ? (stopWatchingForValueChange(), startWatchingForValueChange(target, targetInst)) : "topBlur" === topLevelType && stopWatchingForValueChange(); + } + function getTargetInstForInputEventPolyfill(topLevelType, targetInst, nativeEvent) { + if ("topSelectionChange" === topLevelType || "topKeyUp" === topLevelType || "topKeyDown" === topLevelType) return getInstIfValueChanged(activeElementInst, nativeEvent); + } + function shouldUseClickEvent(elem) { + var nodeName = elem.nodeName; + return nodeName && "input" === nodeName.toLowerCase() && ("checkbox" === elem.type || "radio" === elem.type); + } + function getTargetInstForClickEvent(topLevelType, targetInst, nativeEvent) { + if ("topClick" === topLevelType) return getInstIfValueChanged(targetInst, nativeEvent); + } + function getTargetInstForInputOrChangeEvent(topLevelType, targetInst, nativeEvent) { + if ("topInput" === topLevelType || "topChange" === topLevelType) return getInstIfValueChanged(targetInst, nativeEvent); + } + function handleControlledInputBlur(inst, node) { + if (null != inst) { + var state = inst._wrapperState || node._wrapperState; + if (state && state.controlled && "number" === node.type) { + var value = "" + node.value; + node.getAttribute("value") !== value && node.setAttribute("value", value); + } + } + } + var EventPluginHub = __webpack_require__(47), EventPropagators = __webpack_require__(46), ExecutionEnvironment = __webpack_require__(53), ReactDOMComponentTree = __webpack_require__(39), ReactUpdates = __webpack_require__(61), SyntheticEvent = __webpack_require__(58), inputValueTracking = __webpack_require__(74), getEventTarget = __webpack_require__(75), isEventSupported = __webpack_require__(76), isTextInputElement = __webpack_require__(77), eventTypes = { + change: { + phasedRegistrationNames: { + bubbled: "onChange", + captured: "onChangeCapture" + }, + dependencies: [ "topBlur", "topChange", "topClick", "topFocus", "topInput", "topKeyDown", "topKeyUp", "topSelectionChange" ] + } + }, activeElement = null, activeElementInst = null, doesChangeEventBubble = !1; + ExecutionEnvironment.canUseDOM && (doesChangeEventBubble = isEventSupported("change") && (!document.documentMode || document.documentMode > 8)); + var isInputEventSupported = !1; + ExecutionEnvironment.canUseDOM && (isInputEventSupported = isEventSupported("input") && (!("documentMode" in document) || document.documentMode > 9)); + var ChangeEventPlugin = { + eventTypes: eventTypes, + _allowSimulatedPassThrough: !0, + _isInputEventSupported: isInputEventSupported, + extractEvents: function(topLevelType, targetInst, nativeEvent, nativeEventTarget) { + var getTargetInstFunc, handleEventFunc, targetNode = targetInst ? ReactDOMComponentTree.getNodeFromInstance(targetInst) : window; + if (shouldUseChangeEvent(targetNode) ? doesChangeEventBubble ? getTargetInstFunc = getTargetInstForChangeEvent : handleEventFunc = handleEventsForChangeEventIE8 : isTextInputElement(targetNode) ? isInputEventSupported ? getTargetInstFunc = getTargetInstForInputOrChangeEvent : (getTargetInstFunc = getTargetInstForInputEventPolyfill, + handleEventFunc = handleEventsForInputEventPolyfill) : shouldUseClickEvent(targetNode) && (getTargetInstFunc = getTargetInstForClickEvent), + getTargetInstFunc) { + var inst = getTargetInstFunc(topLevelType, targetInst, nativeEvent); + if (inst) { + var event = createAndAccumulateChangeEvent(inst, nativeEvent, nativeEventTarget); + return event; + } + } + handleEventFunc && handleEventFunc(topLevelType, targetNode, targetInst), "topBlur" === topLevelType && handleControlledInputBlur(targetInst, targetNode); + } + }; + module.exports = ChangeEventPlugin; +}, function(module, exports, __webpack_require__) { + (function(process) { + "use strict"; + function ensureInjected() { + ReactUpdates.ReactReconcileTransaction && batchingStrategy ? void 0 : "production" !== process.env.NODE_ENV ? invariant(!1, "ReactUpdates: must inject a reconcile transaction class and batching strategy") : _prodInvariant("123"); + } + function ReactUpdatesFlushTransaction() { + this.reinitializeTransaction(), this.dirtyComponentsLength = null, this.callbackQueue = CallbackQueue.getPooled(), + this.reconcileTransaction = ReactUpdates.ReactReconcileTransaction.getPooled(!0); + } + function batchedUpdates(callback, a, b, c, d, e) { + return ensureInjected(), batchingStrategy.batchedUpdates(callback, a, b, c, d, e); + } + function mountOrderComparator(c1, c2) { + return c1._mountOrder - c2._mountOrder; + } + function runBatchedUpdates(transaction) { + var len = transaction.dirtyComponentsLength; + len !== dirtyComponents.length ? "production" !== process.env.NODE_ENV ? invariant(!1, "Expected flush transaction's stored dirty-components length (%s) to match dirty-components array length (%s).", len, dirtyComponents.length) : _prodInvariant("124", len, dirtyComponents.length) : void 0, + dirtyComponents.sort(mountOrderComparator), updateBatchNumber++; + for (var i = 0; i < len; i++) { + var component = dirtyComponents[i], callbacks = component._pendingCallbacks; + component._pendingCallbacks = null; + var markerName; + if (ReactFeatureFlags.logTopLevelRenders) { + var namedComponent = component; + component._currentElement.type.isReactTopLevelWrapper && (namedComponent = component._renderedComponent), + markerName = "React update: " + namedComponent.getName(), console.time(markerName); + } + if (ReactReconciler.performUpdateIfNecessary(component, transaction.reconcileTransaction, updateBatchNumber), + markerName && console.timeEnd(markerName), callbacks) for (var j = 0; j < callbacks.length; j++) transaction.callbackQueue.enqueue(callbacks[j], component.getPublicInstance()); + } + } + function enqueueUpdate(component) { + return ensureInjected(), batchingStrategy.isBatchingUpdates ? (dirtyComponents.push(component), + void (null == component._updateBatchNumber && (component._updateBatchNumber = updateBatchNumber + 1))) : void batchingStrategy.batchedUpdates(enqueueUpdate, component); + } + function asap(callback, context) { + batchingStrategy.isBatchingUpdates ? void 0 : "production" !== process.env.NODE_ENV ? invariant(!1, "ReactUpdates.asap: Can't enqueue an asap callback in a context whereupdates are not being batched.") : _prodInvariant("125"), + asapCallbackQueue.enqueue(callback, context), asapEnqueued = !0; + } + var _prodInvariant = __webpack_require__(40), _assign = __webpack_require__(4), CallbackQueue = __webpack_require__(62), PooledClass = __webpack_require__(55), ReactFeatureFlags = __webpack_require__(63), ReactReconciler = __webpack_require__(64), Transaction = __webpack_require__(73), invariant = __webpack_require__(12), dirtyComponents = [], updateBatchNumber = 0, asapCallbackQueue = CallbackQueue.getPooled(), asapEnqueued = !1, batchingStrategy = null, NESTED_UPDATES = { + initialize: function() { + this.dirtyComponentsLength = dirtyComponents.length; + }, + close: function() { + this.dirtyComponentsLength !== dirtyComponents.length ? (dirtyComponents.splice(0, this.dirtyComponentsLength), + flushBatchedUpdates()) : dirtyComponents.length = 0; + } + }, UPDATE_QUEUEING = { + initialize: function() { + this.callbackQueue.reset(); + }, + close: function() { + this.callbackQueue.notifyAll(); + } + }, TRANSACTION_WRAPPERS = [ NESTED_UPDATES, UPDATE_QUEUEING ]; + _assign(ReactUpdatesFlushTransaction.prototype, Transaction, { + getTransactionWrappers: function() { + return TRANSACTION_WRAPPERS; + }, + destructor: function() { + this.dirtyComponentsLength = null, CallbackQueue.release(this.callbackQueue), this.callbackQueue = null, + ReactUpdates.ReactReconcileTransaction.release(this.reconcileTransaction), this.reconcileTransaction = null; + }, + perform: function(method, scope, a) { + return Transaction.perform.call(this, this.reconcileTransaction.perform, this.reconcileTransaction, method, scope, a); + } + }), PooledClass.addPoolingTo(ReactUpdatesFlushTransaction); + var flushBatchedUpdates = function() { + for (;dirtyComponents.length || asapEnqueued; ) { + if (dirtyComponents.length) { + var transaction = ReactUpdatesFlushTransaction.getPooled(); + transaction.perform(runBatchedUpdates, null, transaction), ReactUpdatesFlushTransaction.release(transaction); + } + if (asapEnqueued) { + asapEnqueued = !1; + var queue = asapCallbackQueue; + asapCallbackQueue = CallbackQueue.getPooled(), queue.notifyAll(), CallbackQueue.release(queue); + } + } + }, ReactUpdatesInjection = { + injectReconcileTransaction: function(ReconcileTransaction) { + ReconcileTransaction ? void 0 : "production" !== process.env.NODE_ENV ? invariant(!1, "ReactUpdates: must provide a reconcile transaction class") : _prodInvariant("126"), + ReactUpdates.ReactReconcileTransaction = ReconcileTransaction; + }, + injectBatchingStrategy: function(_batchingStrategy) { + _batchingStrategy ? void 0 : "production" !== process.env.NODE_ENV ? invariant(!1, "ReactUpdates: must provide a batching strategy") : _prodInvariant("127"), + "function" != typeof _batchingStrategy.batchedUpdates ? "production" !== process.env.NODE_ENV ? invariant(!1, "ReactUpdates: must provide a batchedUpdates() function") : _prodInvariant("128") : void 0, + "boolean" != typeof _batchingStrategy.isBatchingUpdates ? "production" !== process.env.NODE_ENV ? invariant(!1, "ReactUpdates: must provide an isBatchingUpdates boolean attribute") : _prodInvariant("129") : void 0, + batchingStrategy = _batchingStrategy; + } + }, ReactUpdates = { + ReactReconcileTransaction: null, + batchedUpdates: batchedUpdates, + enqueueUpdate: enqueueUpdate, + flushBatchedUpdates: flushBatchedUpdates, + injection: ReactUpdatesInjection, + asap: asap + }; + module.exports = ReactUpdates; + }).call(exports, __webpack_require__(3)); +}, function(module, exports, __webpack_require__) { + (function(process) { + "use strict"; + function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function"); + } + var _prodInvariant = __webpack_require__(40), PooledClass = __webpack_require__(55), invariant = __webpack_require__(12), CallbackQueue = function() { + function CallbackQueue(arg) { + _classCallCheck(this, CallbackQueue), this._callbacks = null, this._contexts = null, + this._arg = arg; + } + return CallbackQueue.prototype.enqueue = function(callback, context) { + this._callbacks = this._callbacks || [], this._callbacks.push(callback), this._contexts = this._contexts || [], + this._contexts.push(context); + }, CallbackQueue.prototype.notifyAll = function() { + var callbacks = this._callbacks, contexts = this._contexts, arg = this._arg; + if (callbacks && contexts) { + callbacks.length !== contexts.length ? "production" !== process.env.NODE_ENV ? invariant(!1, "Mismatched list of contexts in callback queue") : _prodInvariant("24") : void 0, + this._callbacks = null, this._contexts = null; + for (var i = 0; i < callbacks.length; i++) callbacks[i].call(contexts[i], arg); + callbacks.length = 0, contexts.length = 0; + } + }, CallbackQueue.prototype.checkpoint = function() { + return this._callbacks ? this._callbacks.length : 0; + }, CallbackQueue.prototype.rollback = function(len) { + this._callbacks && this._contexts && (this._callbacks.length = len, this._contexts.length = len); + }, CallbackQueue.prototype.reset = function() { + this._callbacks = null, this._contexts = null; + }, CallbackQueue.prototype.destructor = function() { + this.reset(); + }, CallbackQueue; + }(); + module.exports = PooledClass.addPoolingTo(CallbackQueue); + }).call(exports, __webpack_require__(3)); +}, function(module, exports) { + "use strict"; + var ReactFeatureFlags = { + logTopLevelRenders: !1 + }; + module.exports = ReactFeatureFlags; +}, function(module, exports, __webpack_require__) { + (function(process) { + "use strict"; + function attachRefs() { + ReactRef.attachRefs(this, this._currentElement); + } + var ReactRef = __webpack_require__(65), ReactInstrumentation = __webpack_require__(67), warning = __webpack_require__(8), ReactReconciler = { + mountComponent: function(internalInstance, transaction, hostParent, hostContainerInfo, context, parentDebugID) { + "production" !== process.env.NODE_ENV && 0 !== internalInstance._debugID && ReactInstrumentation.debugTool.onBeforeMountComponent(internalInstance._debugID, internalInstance._currentElement, parentDebugID); + var markup = internalInstance.mountComponent(transaction, hostParent, hostContainerInfo, context, parentDebugID); + return internalInstance._currentElement && null != internalInstance._currentElement.ref && transaction.getReactMountReady().enqueue(attachRefs, internalInstance), + "production" !== process.env.NODE_ENV && 0 !== internalInstance._debugID && ReactInstrumentation.debugTool.onMountComponent(internalInstance._debugID), + markup; + }, + getHostNode: function(internalInstance) { + return internalInstance.getHostNode(); + }, + unmountComponent: function(internalInstance, safely) { + "production" !== process.env.NODE_ENV && 0 !== internalInstance._debugID && ReactInstrumentation.debugTool.onBeforeUnmountComponent(internalInstance._debugID), + ReactRef.detachRefs(internalInstance, internalInstance._currentElement), internalInstance.unmountComponent(safely), + "production" !== process.env.NODE_ENV && 0 !== internalInstance._debugID && ReactInstrumentation.debugTool.onUnmountComponent(internalInstance._debugID); + }, + receiveComponent: function(internalInstance, nextElement, transaction, context) { + var prevElement = internalInstance._currentElement; + if (nextElement !== prevElement || context !== internalInstance._context) { + "production" !== process.env.NODE_ENV && 0 !== internalInstance._debugID && ReactInstrumentation.debugTool.onBeforeUpdateComponent(internalInstance._debugID, nextElement); + var refsChanged = ReactRef.shouldUpdateRefs(prevElement, nextElement); + refsChanged && ReactRef.detachRefs(internalInstance, prevElement), internalInstance.receiveComponent(nextElement, transaction, context), + refsChanged && internalInstance._currentElement && null != internalInstance._currentElement.ref && transaction.getReactMountReady().enqueue(attachRefs, internalInstance), + "production" !== process.env.NODE_ENV && 0 !== internalInstance._debugID && ReactInstrumentation.debugTool.onUpdateComponent(internalInstance._debugID); + } + }, + performUpdateIfNecessary: function(internalInstance, transaction, updateBatchNumber) { + return internalInstance._updateBatchNumber !== updateBatchNumber ? void ("production" !== process.env.NODE_ENV ? warning(null == internalInstance._updateBatchNumber || internalInstance._updateBatchNumber === updateBatchNumber + 1, "performUpdateIfNecessary: Unexpected batch number (current %s, pending %s)", updateBatchNumber, internalInstance._updateBatchNumber) : void 0) : ("production" !== process.env.NODE_ENV && 0 !== internalInstance._debugID && ReactInstrumentation.debugTool.onBeforeUpdateComponent(internalInstance._debugID, internalInstance._currentElement), + internalInstance.performUpdateIfNecessary(transaction), void ("production" !== process.env.NODE_ENV && 0 !== internalInstance._debugID && ReactInstrumentation.debugTool.onUpdateComponent(internalInstance._debugID))); + } + }; + module.exports = ReactReconciler; + }).call(exports, __webpack_require__(3)); +}, function(module, exports, __webpack_require__) { + "use strict"; + function attachRef(ref, component, owner) { + "function" == typeof ref ? ref(component.getPublicInstance()) : ReactOwner.addComponentAsRefTo(component, ref, owner); + } + function detachRef(ref, component, owner) { + "function" == typeof ref ? ref(null) : ReactOwner.removeComponentAsRefFrom(component, ref, owner); + } + var ReactOwner = __webpack_require__(66), ReactRef = {}; + ReactRef.attachRefs = function(instance, element) { + if (null !== element && "object" == typeof element) { + var ref = element.ref; + null != ref && attachRef(ref, instance, element._owner); + } + }, ReactRef.shouldUpdateRefs = function(prevElement, nextElement) { + var prevRef = null, prevOwner = null; + null !== prevElement && "object" == typeof prevElement && (prevRef = prevElement.ref, + prevOwner = prevElement._owner); + var nextRef = null, nextOwner = null; + return null !== nextElement && "object" == typeof nextElement && (nextRef = nextElement.ref, + nextOwner = nextElement._owner), prevRef !== nextRef || "string" == typeof nextRef && nextOwner !== prevOwner; + }, ReactRef.detachRefs = function(instance, element) { + if (null !== element && "object" == typeof element) { + var ref = element.ref; + null != ref && detachRef(ref, instance, element._owner); + } + }, module.exports = ReactRef; +}, function(module, exports, __webpack_require__) { + (function(process) { + "use strict"; + function isValidOwner(object) { + return !(!object || "function" != typeof object.attachRef || "function" != typeof object.detachRef); + } + var _prodInvariant = __webpack_require__(40), invariant = __webpack_require__(12), ReactOwner = { + addComponentAsRefTo: function(component, ref, owner) { + isValidOwner(owner) ? void 0 : "production" !== process.env.NODE_ENV ? invariant(!1, "addComponentAsRefTo(...): Only a ReactOwner can have refs. You might be adding a ref to a component that was not created inside a component's `render` method, or you have multiple copies of React loaded (details: https://fb.me/react-refs-must-have-owner).") : _prodInvariant("119"), + owner.attachRef(ref, component); + }, + removeComponentAsRefFrom: function(component, ref, owner) { + isValidOwner(owner) ? void 0 : "production" !== process.env.NODE_ENV ? invariant(!1, "removeComponentAsRefFrom(...): Only a ReactOwner can have refs. You might be removing a ref to a component that was not created inside a component's `render` method, or you have multiple copies of React loaded (details: https://fb.me/react-refs-must-have-owner).") : _prodInvariant("120"); + var ownerPublicInstance = owner.getPublicInstance(); + ownerPublicInstance && ownerPublicInstance.refs[ref] === component.getPublicInstance() && owner.detachRef(ref); + } + }; + module.exports = ReactOwner; + }).call(exports, __webpack_require__(3)); +}, function(module, exports, __webpack_require__) { + (function(process) { + "use strict"; + var debugTool = null; + if ("production" !== process.env.NODE_ENV) { + var ReactDebugTool = __webpack_require__(68); + debugTool = ReactDebugTool; + } + module.exports = { + debugTool: debugTool + }; + }).call(exports, __webpack_require__(3)); +}, function(module, exports, __webpack_require__) { + (function(process) { + "use strict"; + function callHook(event, fn, context, arg1, arg2, arg3, arg4, arg5) { + try { + fn.call(context, arg1, arg2, arg3, arg4, arg5); + } catch (e) { + "production" !== process.env.NODE_ENV ? warning(didHookThrowForEvent[event], "Exception thrown by hook while handling %s: %s", event, e + "\n" + e.stack) : void 0, + didHookThrowForEvent[event] = !0; + } + } + function emitEvent(event, arg1, arg2, arg3, arg4, arg5) { + for (var i = 0; i < hooks.length; i++) { + var hook = hooks[i], fn = hook[event]; + fn && callHook(event, fn, hook, arg1, arg2, arg3, arg4, arg5); + } + } + function clearHistory() { + ReactComponentTreeHook.purgeUnmountedComponents(), ReactHostOperationHistoryHook.clearHistory(); + } + function getTreeSnapshot(registeredIDs) { + return registeredIDs.reduce(function(tree, id) { + var ownerID = ReactComponentTreeHook.getOwnerID(id), parentID = ReactComponentTreeHook.getParentID(id); + return tree[id] = { + displayName: ReactComponentTreeHook.getDisplayName(id), + text: ReactComponentTreeHook.getText(id), + updateCount: ReactComponentTreeHook.getUpdateCount(id), + childIDs: ReactComponentTreeHook.getChildIDs(id), + ownerID: ownerID || parentID && ReactComponentTreeHook.getOwnerID(parentID) || 0, + parentID: parentID + }, tree; + }, {}); + } + function resetMeasurements() { + var previousStartTime = currentFlushStartTime, previousMeasurements = currentFlushMeasurements, previousOperations = ReactHostOperationHistoryHook.getHistory(); + if (0 === currentFlushNesting) return currentFlushStartTime = 0, currentFlushMeasurements = [], + void clearHistory(); + if (previousMeasurements.length || previousOperations.length) { + var registeredIDs = ReactComponentTreeHook.getRegisteredIDs(); + flushHistory.push({ + duration: performanceNow() - previousStartTime, + measurements: previousMeasurements || [], + operations: previousOperations || [], + treeSnapshot: getTreeSnapshot(registeredIDs) + }); + } + clearHistory(), currentFlushStartTime = performanceNow(), currentFlushMeasurements = []; + } + function checkDebugID(debugID) { + var allowRoot = arguments.length > 1 && void 0 !== arguments[1] && arguments[1]; + allowRoot && 0 === debugID || debugID || ("production" !== process.env.NODE_ENV ? warning(!1, "ReactDebugTool: debugID may not be empty.") : void 0); + } + function beginLifeCycleTimer(debugID, timerType) { + 0 !== currentFlushNesting && (currentTimerType && !lifeCycleTimerHasWarned && ("production" !== process.env.NODE_ENV ? warning(!1, "There is an internal error in the React performance measurement code. Did not expect %s timer to start while %s timer is still in progress for %s instance.", timerType, currentTimerType || "no", debugID === currentTimerDebugID ? "the same" : "another") : void 0, + lifeCycleTimerHasWarned = !0), currentTimerStartTime = performanceNow(), currentTimerNestedFlushDuration = 0, + currentTimerDebugID = debugID, currentTimerType = timerType); + } + function endLifeCycleTimer(debugID, timerType) { + 0 !== currentFlushNesting && (currentTimerType === timerType || lifeCycleTimerHasWarned || ("production" !== process.env.NODE_ENV ? warning(!1, "There is an internal error in the React performance measurement code. We did not expect %s timer to stop while %s timer is still in progress for %s instance. Please report this as a bug in React.", timerType, currentTimerType || "no", debugID === currentTimerDebugID ? "the same" : "another") : void 0, + lifeCycleTimerHasWarned = !0), isProfiling && currentFlushMeasurements.push({ + timerType: timerType, + instanceID: debugID, + duration: performanceNow() - currentTimerStartTime - currentTimerNestedFlushDuration + }), currentTimerStartTime = 0, currentTimerNestedFlushDuration = 0, currentTimerDebugID = null, + currentTimerType = null); + } + function pauseCurrentLifeCycleTimer() { + var currentTimer = { + startTime: currentTimerStartTime, + nestedFlushStartTime: performanceNow(), + debugID: currentTimerDebugID, + timerType: currentTimerType + }; + lifeCycleTimerStack.push(currentTimer), currentTimerStartTime = 0, currentTimerNestedFlushDuration = 0, + currentTimerDebugID = null, currentTimerType = null; + } + function resumeCurrentLifeCycleTimer() { + var _lifeCycleTimerStack$ = lifeCycleTimerStack.pop(), startTime = _lifeCycleTimerStack$.startTime, nestedFlushStartTime = _lifeCycleTimerStack$.nestedFlushStartTime, debugID = _lifeCycleTimerStack$.debugID, timerType = _lifeCycleTimerStack$.timerType, nestedFlushDuration = performanceNow() - nestedFlushStartTime; + currentTimerStartTime = startTime, currentTimerNestedFlushDuration += nestedFlushDuration, + currentTimerDebugID = debugID, currentTimerType = timerType; + } + function shouldMark(debugID) { + if (!isProfiling || !canUsePerformanceMeasure) return !1; + var element = ReactComponentTreeHook.getElement(debugID); + if (null == element || "object" != typeof element) return !1; + var isHostElement = "string" == typeof element.type; + return !isHostElement; + } + function markBegin(debugID, markType) { + if (shouldMark(debugID)) { + var markName = debugID + "::" + markType; + lastMarkTimeStamp = performanceNow(), performance.mark(markName); + } + } + function markEnd(debugID, markType) { + if (shouldMark(debugID)) { + var markName = debugID + "::" + markType, displayName = ReactComponentTreeHook.getDisplayName(debugID) || "Unknown", timeStamp = performanceNow(); + if (timeStamp - lastMarkTimeStamp > .1) { + var measurementName = displayName + " [" + markType + "]"; + performance.measure(measurementName, markName); + } + performance.clearMarks(markName), measurementName && performance.clearMeasures(measurementName); + } + } + var ReactInvalidSetStateWarningHook = __webpack_require__(69), ReactHostOperationHistoryHook = __webpack_require__(70), ReactComponentTreeHook = __webpack_require__(24), ExecutionEnvironment = __webpack_require__(53), performanceNow = __webpack_require__(71), warning = __webpack_require__(8), hooks = [], didHookThrowForEvent = {}, isProfiling = !1, flushHistory = [], lifeCycleTimerStack = [], currentFlushNesting = 0, currentFlushMeasurements = [], currentFlushStartTime = 0, currentTimerDebugID = null, currentTimerStartTime = 0, currentTimerNestedFlushDuration = 0, currentTimerType = null, lifeCycleTimerHasWarned = !1, lastMarkTimeStamp = 0, canUsePerformanceMeasure = "undefined" != typeof performance && "function" == typeof performance.mark && "function" == typeof performance.clearMarks && "function" == typeof performance.measure && "function" == typeof performance.clearMeasures, ReactDebugTool = { + addHook: function(hook) { + hooks.push(hook); + }, + removeHook: function(hook) { + for (var i = 0; i < hooks.length; i++) hooks[i] === hook && (hooks.splice(i, 1), + i--); + }, + isProfiling: function() { + return isProfiling; + }, + beginProfiling: function() { + isProfiling || (isProfiling = !0, flushHistory.length = 0, resetMeasurements(), + ReactDebugTool.addHook(ReactHostOperationHistoryHook)); + }, + endProfiling: function() { + isProfiling && (isProfiling = !1, resetMeasurements(), ReactDebugTool.removeHook(ReactHostOperationHistoryHook)); + }, + getFlushHistory: function() { + return flushHistory; + }, + onBeginFlush: function() { + currentFlushNesting++, resetMeasurements(), pauseCurrentLifeCycleTimer(), emitEvent("onBeginFlush"); + }, + onEndFlush: function() { + resetMeasurements(), currentFlushNesting--, resumeCurrentLifeCycleTimer(), emitEvent("onEndFlush"); + }, + onBeginLifeCycleTimer: function(debugID, timerType) { + checkDebugID(debugID), emitEvent("onBeginLifeCycleTimer", debugID, timerType), markBegin(debugID, timerType), + beginLifeCycleTimer(debugID, timerType); + }, + onEndLifeCycleTimer: function(debugID, timerType) { + checkDebugID(debugID), endLifeCycleTimer(debugID, timerType), markEnd(debugID, timerType), + emitEvent("onEndLifeCycleTimer", debugID, timerType); + }, + onBeginProcessingChildContext: function() { + emitEvent("onBeginProcessingChildContext"); + }, + onEndProcessingChildContext: function() { + emitEvent("onEndProcessingChildContext"); + }, + onHostOperation: function(operation) { + checkDebugID(operation.instanceID), emitEvent("onHostOperation", operation); + }, + onSetState: function() { + emitEvent("onSetState"); + }, + onSetChildren: function(debugID, childDebugIDs) { + checkDebugID(debugID), childDebugIDs.forEach(checkDebugID), emitEvent("onSetChildren", debugID, childDebugIDs); + }, + onBeforeMountComponent: function(debugID, element, parentDebugID) { + checkDebugID(debugID), checkDebugID(parentDebugID, !0), emitEvent("onBeforeMountComponent", debugID, element, parentDebugID), + markBegin(debugID, "mount"); + }, + onMountComponent: function(debugID) { + checkDebugID(debugID), markEnd(debugID, "mount"), emitEvent("onMountComponent", debugID); + }, + onBeforeUpdateComponent: function(debugID, element) { + checkDebugID(debugID), emitEvent("onBeforeUpdateComponent", debugID, element), markBegin(debugID, "update"); + }, + onUpdateComponent: function(debugID) { + checkDebugID(debugID), markEnd(debugID, "update"), emitEvent("onUpdateComponent", debugID); + }, + onBeforeUnmountComponent: function(debugID) { + checkDebugID(debugID), emitEvent("onBeforeUnmountComponent", debugID), markBegin(debugID, "unmount"); + }, + onUnmountComponent: function(debugID) { + checkDebugID(debugID), markEnd(debugID, "unmount"), emitEvent("onUnmountComponent", debugID); + }, + onTestEvent: function() { + emitEvent("onTestEvent"); + } + }; + ReactDebugTool.addDevtool = ReactDebugTool.addHook, ReactDebugTool.removeDevtool = ReactDebugTool.removeHook, + ReactDebugTool.addHook(ReactInvalidSetStateWarningHook), ReactDebugTool.addHook(ReactComponentTreeHook); + var url = ExecutionEnvironment.canUseDOM && window.location.href || ""; + /[?&]react_perf\b/.test(url) && ReactDebugTool.beginProfiling(), module.exports = ReactDebugTool; + }).call(exports, __webpack_require__(3)); +}, function(module, exports, __webpack_require__) { + (function(process) { + "use strict"; + var warning = __webpack_require__(8); + if ("production" !== process.env.NODE_ENV) var processingChildContext = !1, warnInvalidSetState = function() { + "production" !== process.env.NODE_ENV ? warning(!processingChildContext, "setState(...): Cannot call setState() inside getChildContext()") : void 0; + }; + var ReactInvalidSetStateWarningHook = { + onBeginProcessingChildContext: function() { + processingChildContext = !0; + }, + onEndProcessingChildContext: function() { + processingChildContext = !1; + }, + onSetState: function() { + warnInvalidSetState(); + } + }; + module.exports = ReactInvalidSetStateWarningHook; + }).call(exports, __webpack_require__(3)); +}, function(module, exports) { + "use strict"; + var history = [], ReactHostOperationHistoryHook = { + onHostOperation: function(operation) { + history.push(operation); + }, + clearHistory: function() { + ReactHostOperationHistoryHook._preventClearing || (history = []); + }, + getHistory: function() { + return history; + } + }; + module.exports = ReactHostOperationHistoryHook; +}, function(module, exports, __webpack_require__) { + "use strict"; + var performanceNow, performance = __webpack_require__(72); + performanceNow = performance.now ? function() { + return performance.now(); + } : function() { + return Date.now(); + }, module.exports = performanceNow; +}, function(module, exports, __webpack_require__) { + "use strict"; + var performance, ExecutionEnvironment = __webpack_require__(53); + ExecutionEnvironment.canUseDOM && (performance = window.performance || window.msPerformance || window.webkitPerformance), + module.exports = performance || {}; +}, function(module, exports, __webpack_require__) { + (function(process) { + "use strict"; + var _prodInvariant = __webpack_require__(40), invariant = __webpack_require__(12), OBSERVED_ERROR = {}, TransactionImpl = { + reinitializeTransaction: function() { + this.transactionWrappers = this.getTransactionWrappers(), this.wrapperInitData ? this.wrapperInitData.length = 0 : this.wrapperInitData = [], + this._isInTransaction = !1; + }, + _isInTransaction: !1, + getTransactionWrappers: null, + isInTransaction: function() { + return !!this._isInTransaction; + }, + perform: function(method, scope, a, b, c, d, e, f) { + this.isInTransaction() ? "production" !== process.env.NODE_ENV ? invariant(!1, "Transaction.perform(...): Cannot initialize a transaction when there is already an outstanding transaction.") : _prodInvariant("27") : void 0; + var errorThrown, ret; + try { + this._isInTransaction = !0, errorThrown = !0, this.initializeAll(0), ret = method.call(scope, a, b, c, d, e, f), + errorThrown = !1; + } finally { + try { + if (errorThrown) try { + this.closeAll(0); + } catch (err) {} else this.closeAll(0); + } finally { + this._isInTransaction = !1; + } + } + return ret; + }, + initializeAll: function(startIndex) { + for (var transactionWrappers = this.transactionWrappers, i = startIndex; i < transactionWrappers.length; i++) { + var wrapper = transactionWrappers[i]; + try { + this.wrapperInitData[i] = OBSERVED_ERROR, this.wrapperInitData[i] = wrapper.initialize ? wrapper.initialize.call(this) : null; + } finally { + if (this.wrapperInitData[i] === OBSERVED_ERROR) try { + this.initializeAll(i + 1); + } catch (err) {} + } + } + }, + closeAll: function(startIndex) { + this.isInTransaction() ? void 0 : "production" !== process.env.NODE_ENV ? invariant(!1, "Transaction.closeAll(): Cannot close transaction when none are open.") : _prodInvariant("28"); + for (var transactionWrappers = this.transactionWrappers, i = startIndex; i < transactionWrappers.length; i++) { + var errorThrown, wrapper = transactionWrappers[i], initData = this.wrapperInitData[i]; + try { + errorThrown = !0, initData !== OBSERVED_ERROR && wrapper.close && wrapper.close.call(this, initData), + errorThrown = !1; + } finally { + if (errorThrown) try { + this.closeAll(i + 1); + } catch (e) {} + } + } + this.wrapperInitData.length = 0; + } + }; + module.exports = TransactionImpl; + }).call(exports, __webpack_require__(3)); +}, function(module, exports, __webpack_require__) { + "use strict"; + function isCheckable(elem) { + var type = elem.type, nodeName = elem.nodeName; + return nodeName && "input" === nodeName.toLowerCase() && ("checkbox" === type || "radio" === type); + } + function getTracker(inst) { + return inst._wrapperState.valueTracker; + } + function attachTracker(inst, tracker) { + inst._wrapperState.valueTracker = tracker; + } + function detachTracker(inst) { + delete inst._wrapperState.valueTracker; + } + function getValueFromNode(node) { + var value; + return node && (value = isCheckable(node) ? "" + node.checked : node.value), value; + } + var ReactDOMComponentTree = __webpack_require__(39), inputValueTracking = { + _getTrackerFromNode: function(node) { + return getTracker(ReactDOMComponentTree.getInstanceFromNode(node)); + }, + track: function(inst) { + if (!getTracker(inst)) { + var node = ReactDOMComponentTree.getNodeFromInstance(inst), valueField = isCheckable(node) ? "checked" : "value", descriptor = Object.getOwnPropertyDescriptor(node.constructor.prototype, valueField), currentValue = "" + node[valueField]; + node.hasOwnProperty(valueField) || "function" != typeof descriptor.get || "function" != typeof descriptor.set || (Object.defineProperty(node, valueField, { + enumerable: descriptor.enumerable, + configurable: !0, + get: function() { + return descriptor.get.call(this); + }, + set: function(value) { + currentValue = "" + value, descriptor.set.call(this, value); + } + }), attachTracker(inst, { + getValue: function() { + return currentValue; + }, + setValue: function(value) { + currentValue = "" + value; + }, + stopTracking: function() { + detachTracker(inst), delete node[valueField]; + } + })); + } + }, + updateValueIfChanged: function(inst) { + if (!inst) return !1; + var tracker = getTracker(inst); + if (!tracker) return inputValueTracking.track(inst), !0; + var lastValue = tracker.getValue(), nextValue = getValueFromNode(ReactDOMComponentTree.getNodeFromInstance(inst)); + return nextValue !== lastValue && (tracker.setValue(nextValue), !0); + }, + stopTracking: function(inst) { + var tracker = getTracker(inst); + tracker && tracker.stopTracking(); + } + }; + module.exports = inputValueTracking; +}, function(module, exports) { + "use strict"; + function getEventTarget(nativeEvent) { + var target = nativeEvent.target || nativeEvent.srcElement || window; + return target.correspondingUseElement && (target = target.correspondingUseElement), + 3 === target.nodeType ? target.parentNode : target; + } + module.exports = getEventTarget; +}, function(module, exports, __webpack_require__) { + "use strict"; + function isEventSupported(eventNameSuffix, capture) { + if (!ExecutionEnvironment.canUseDOM || capture && !("addEventListener" in document)) return !1; + var eventName = "on" + eventNameSuffix, isSupported = eventName in document; + if (!isSupported) { + var element = document.createElement("div"); + element.setAttribute(eventName, "return;"), isSupported = "function" == typeof element[eventName]; + } + return !isSupported && useHasFeature && "wheel" === eventNameSuffix && (isSupported = document.implementation.hasFeature("Events.wheel", "3.0")), + isSupported; + } + var useHasFeature, ExecutionEnvironment = __webpack_require__(53); + ExecutionEnvironment.canUseDOM && (useHasFeature = document.implementation && document.implementation.hasFeature && document.implementation.hasFeature("", "") !== !0), + module.exports = isEventSupported; +}, function(module, exports) { + "use strict"; + function isTextInputElement(elem) { + var nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase(); + return "input" === nodeName ? !!supportedInputTypes[elem.type] : "textarea" === nodeName; + } + var supportedInputTypes = { + color: !0, + date: !0, + datetime: !0, + "datetime-local": !0, + email: !0, + month: !0, + number: !0, + password: !0, + range: !0, + search: !0, + tel: !0, + text: !0, + time: !0, + url: !0, + week: !0 + }; + module.exports = isTextInputElement; +}, function(module, exports) { + "use strict"; + var DefaultEventPluginOrder = [ "ResponderEventPlugin", "SimpleEventPlugin", "TapEventPlugin", "EnterLeaveEventPlugin", "ChangeEventPlugin", "SelectEventPlugin", "BeforeInputEventPlugin" ]; + module.exports = DefaultEventPluginOrder; +}, function(module, exports, __webpack_require__) { + "use strict"; + var EventPropagators = __webpack_require__(46), ReactDOMComponentTree = __webpack_require__(39), SyntheticMouseEvent = __webpack_require__(80), eventTypes = { + mouseEnter: { + registrationName: "onMouseEnter", + dependencies: [ "topMouseOut", "topMouseOver" ] + }, + mouseLeave: { + registrationName: "onMouseLeave", + dependencies: [ "topMouseOut", "topMouseOver" ] + } + }, EnterLeaveEventPlugin = { + eventTypes: eventTypes, + extractEvents: function(topLevelType, targetInst, nativeEvent, nativeEventTarget) { + if ("topMouseOver" === topLevelType && (nativeEvent.relatedTarget || nativeEvent.fromElement)) return null; + if ("topMouseOut" !== topLevelType && "topMouseOver" !== topLevelType) return null; + var win; + if (nativeEventTarget.window === nativeEventTarget) win = nativeEventTarget; else { + var doc = nativeEventTarget.ownerDocument; + win = doc ? doc.defaultView || doc.parentWindow : window; + } + var from, to; + if ("topMouseOut" === topLevelType) { + from = targetInst; + var related = nativeEvent.relatedTarget || nativeEvent.toElement; + to = related ? ReactDOMComponentTree.getClosestInstanceFromNode(related) : null; + } else from = null, to = targetInst; + if (from === to) return null; + var fromNode = null == from ? win : ReactDOMComponentTree.getNodeFromInstance(from), toNode = null == to ? win : ReactDOMComponentTree.getNodeFromInstance(to), leave = SyntheticMouseEvent.getPooled(eventTypes.mouseLeave, from, nativeEvent, nativeEventTarget); + leave.type = "mouseleave", leave.target = fromNode, leave.relatedTarget = toNode; + var enter = SyntheticMouseEvent.getPooled(eventTypes.mouseEnter, to, nativeEvent, nativeEventTarget); + return enter.type = "mouseenter", enter.target = toNode, enter.relatedTarget = fromNode, + EventPropagators.accumulateEnterLeaveDispatches(leave, enter, from, to), [ leave, enter ]; + } + }; + module.exports = EnterLeaveEventPlugin; +}, function(module, exports, __webpack_require__) { + "use strict"; + function SyntheticMouseEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) { + return SyntheticUIEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget); + } + var SyntheticUIEvent = __webpack_require__(81), ViewportMetrics = __webpack_require__(82), getEventModifierState = __webpack_require__(83), MouseEventInterface = { + screenX: null, + screenY: null, + clientX: null, + clientY: null, + ctrlKey: null, + shiftKey: null, + altKey: null, + metaKey: null, + getModifierState: getEventModifierState, + button: function(event) { + var button = event.button; + return "which" in event ? button : 2 === button ? 2 : 4 === button ? 1 : 0; + }, + buttons: null, + relatedTarget: function(event) { + return event.relatedTarget || (event.fromElement === event.srcElement ? event.toElement : event.fromElement); + }, + pageX: function(event) { + return "pageX" in event ? event.pageX : event.clientX + ViewportMetrics.currentScrollLeft; + }, + pageY: function(event) { + return "pageY" in event ? event.pageY : event.clientY + ViewportMetrics.currentScrollTop; + } + }; + SyntheticUIEvent.augmentClass(SyntheticMouseEvent, MouseEventInterface), module.exports = SyntheticMouseEvent; +}, function(module, exports, __webpack_require__) { + "use strict"; + function SyntheticUIEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) { + return SyntheticEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget); + } + var SyntheticEvent = __webpack_require__(58), getEventTarget = __webpack_require__(75), UIEventInterface = { + view: function(event) { + if (event.view) return event.view; + var target = getEventTarget(event); + if (target.window === target) return target; + var doc = target.ownerDocument; + return doc ? doc.defaultView || doc.parentWindow : window; + }, + detail: function(event) { + return event.detail || 0; + } + }; + SyntheticEvent.augmentClass(SyntheticUIEvent, UIEventInterface), module.exports = SyntheticUIEvent; +}, function(module, exports) { + "use strict"; + var ViewportMetrics = { + currentScrollLeft: 0, + currentScrollTop: 0, + refreshScrollValues: function(scrollPosition) { + ViewportMetrics.currentScrollLeft = scrollPosition.x, ViewportMetrics.currentScrollTop = scrollPosition.y; + } + }; + module.exports = ViewportMetrics; +}, function(module, exports) { + "use strict"; + function modifierStateGetter(keyArg) { + var syntheticEvent = this, nativeEvent = syntheticEvent.nativeEvent; + if (nativeEvent.getModifierState) return nativeEvent.getModifierState(keyArg); + var keyProp = modifierKeyToProp[keyArg]; + return !!keyProp && !!nativeEvent[keyProp]; + } + function getEventModifierState(nativeEvent) { + return modifierStateGetter; + } + var modifierKeyToProp = { + Alt: "altKey", + Control: "ctrlKey", + Meta: "metaKey", + Shift: "shiftKey" + }; + module.exports = getEventModifierState; +}, function(module, exports, __webpack_require__) { + "use strict"; + var DOMProperty = __webpack_require__(41), MUST_USE_PROPERTY = DOMProperty.injection.MUST_USE_PROPERTY, HAS_BOOLEAN_VALUE = DOMProperty.injection.HAS_BOOLEAN_VALUE, HAS_NUMERIC_VALUE = DOMProperty.injection.HAS_NUMERIC_VALUE, HAS_POSITIVE_NUMERIC_VALUE = DOMProperty.injection.HAS_POSITIVE_NUMERIC_VALUE, HAS_OVERLOADED_BOOLEAN_VALUE = DOMProperty.injection.HAS_OVERLOADED_BOOLEAN_VALUE, HTMLDOMPropertyConfig = { + isCustomAttribute: RegExp.prototype.test.bind(new RegExp("^(data|aria)-[" + DOMProperty.ATTRIBUTE_NAME_CHAR + "]*$")), + Properties: { + accept: 0, + acceptCharset: 0, + accessKey: 0, + action: 0, + allowFullScreen: HAS_BOOLEAN_VALUE, + allowTransparency: 0, + alt: 0, + as: 0, + async: HAS_BOOLEAN_VALUE, + autoComplete: 0, + autoPlay: HAS_BOOLEAN_VALUE, + capture: HAS_BOOLEAN_VALUE, + cellPadding: 0, + cellSpacing: 0, + charSet: 0, + challenge: 0, + checked: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE, + cite: 0, + classID: 0, + className: 0, + cols: HAS_POSITIVE_NUMERIC_VALUE, + colSpan: 0, + content: 0, + contentEditable: 0, + contextMenu: 0, + controls: HAS_BOOLEAN_VALUE, + coords: 0, + crossOrigin: 0, + data: 0, + dateTime: 0, + default: HAS_BOOLEAN_VALUE, + defer: HAS_BOOLEAN_VALUE, + dir: 0, + disabled: HAS_BOOLEAN_VALUE, + download: HAS_OVERLOADED_BOOLEAN_VALUE, + draggable: 0, + encType: 0, + form: 0, + formAction: 0, + formEncType: 0, + formMethod: 0, + formNoValidate: HAS_BOOLEAN_VALUE, + formTarget: 0, + frameBorder: 0, + headers: 0, + height: 0, + hidden: HAS_BOOLEAN_VALUE, + high: 0, + href: 0, + hrefLang: 0, + htmlFor: 0, + httpEquiv: 0, + icon: 0, + id: 0, + inputMode: 0, + integrity: 0, + is: 0, + keyParams: 0, + keyType: 0, + kind: 0, + label: 0, + lang: 0, + list: 0, + loop: HAS_BOOLEAN_VALUE, + low: 0, + manifest: 0, + marginHeight: 0, + marginWidth: 0, + max: 0, + maxLength: 0, + media: 0, + mediaGroup: 0, + method: 0, + min: 0, + minLength: 0, + multiple: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE, + muted: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE, + name: 0, + nonce: 0, + noValidate: HAS_BOOLEAN_VALUE, + open: HAS_BOOLEAN_VALUE, + optimum: 0, + pattern: 0, + placeholder: 0, + playsInline: HAS_BOOLEAN_VALUE, + poster: 0, + preload: 0, + profile: 0, + radioGroup: 0, + readOnly: HAS_BOOLEAN_VALUE, + referrerPolicy: 0, + rel: 0, + required: HAS_BOOLEAN_VALUE, + reversed: HAS_BOOLEAN_VALUE, + role: 0, + rows: HAS_POSITIVE_NUMERIC_VALUE, + rowSpan: HAS_NUMERIC_VALUE, + sandbox: 0, + scope: 0, + scoped: HAS_BOOLEAN_VALUE, + scrolling: 0, + seamless: HAS_BOOLEAN_VALUE, + selected: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE, + shape: 0, + size: HAS_POSITIVE_NUMERIC_VALUE, + sizes: 0, + span: HAS_POSITIVE_NUMERIC_VALUE, + spellCheck: 0, + src: 0, + srcDoc: 0, + srcLang: 0, + srcSet: 0, + start: HAS_NUMERIC_VALUE, + step: 0, + style: 0, + summary: 0, + tabIndex: 0, + target: 0, + title: 0, + type: 0, + useMap: 0, + value: 0, + width: 0, + wmode: 0, + wrap: 0, + about: 0, + datatype: 0, + inlist: 0, + prefix: 0, + property: 0, + resource: 0, + typeof: 0, + vocab: 0, + autoCapitalize: 0, + autoCorrect: 0, + autoSave: 0, + color: 0, + itemProp: 0, + itemScope: HAS_BOOLEAN_VALUE, + itemType: 0, + itemID: 0, + itemRef: 0, + results: 0, + security: 0, + unselectable: 0 + }, + DOMAttributeNames: { + acceptCharset: "accept-charset", + className: "class", + htmlFor: "for", + httpEquiv: "http-equiv" + }, + DOMPropertyNames: {}, + DOMMutationMethods: { + value: function(node, value) { + return null == value ? node.removeAttribute("value") : void ("number" !== node.type || node.hasAttribute("value") === !1 ? node.setAttribute("value", "" + value) : node.validity && !node.validity.badInput && node.ownerDocument.activeElement !== node && node.setAttribute("value", "" + value)); + } + } + }; + module.exports = HTMLDOMPropertyConfig; +}, function(module, exports, __webpack_require__) { + "use strict"; + var DOMChildrenOperations = __webpack_require__(86), ReactDOMIDOperations = __webpack_require__(97), ReactComponentBrowserEnvironment = { + processChildrenUpdates: ReactDOMIDOperations.dangerouslyProcessChildrenUpdates, + replaceNodeWithMarkup: DOMChildrenOperations.dangerouslyReplaceNodeWithMarkup + }; + module.exports = ReactComponentBrowserEnvironment; +}, function(module, exports, __webpack_require__) { + (function(process) { + "use strict"; + function getNodeAfter(parentNode, node) { + return Array.isArray(node) && (node = node[1]), node ? node.nextSibling : parentNode.firstChild; + } + function insertLazyTreeChildAt(parentNode, childTree, referenceNode) { + DOMLazyTree.insertTreeBefore(parentNode, childTree, referenceNode); + } + function moveChild(parentNode, childNode, referenceNode) { + Array.isArray(childNode) ? moveDelimitedText(parentNode, childNode[0], childNode[1], referenceNode) : insertChildAt(parentNode, childNode, referenceNode); + } + function removeChild(parentNode, childNode) { + if (Array.isArray(childNode)) { + var closingComment = childNode[1]; + childNode = childNode[0], removeDelimitedText(parentNode, childNode, closingComment), + parentNode.removeChild(closingComment); + } + parentNode.removeChild(childNode); + } + function moveDelimitedText(parentNode, openingComment, closingComment, referenceNode) { + for (var node = openingComment; ;) { + var nextNode = node.nextSibling; + if (insertChildAt(parentNode, node, referenceNode), node === closingComment) break; + node = nextNode; + } + } + function removeDelimitedText(parentNode, startNode, closingComment) { + for (;;) { + var node = startNode.nextSibling; + if (node === closingComment) break; + parentNode.removeChild(node); + } + } + function replaceDelimitedText(openingComment, closingComment, stringText) { + var parentNode = openingComment.parentNode, nodeAfterComment = openingComment.nextSibling; + nodeAfterComment === closingComment ? stringText && insertChildAt(parentNode, document.createTextNode(stringText), nodeAfterComment) : stringText ? (setTextContent(nodeAfterComment, stringText), + removeDelimitedText(parentNode, nodeAfterComment, closingComment)) : removeDelimitedText(parentNode, openingComment, closingComment), + "production" !== process.env.NODE_ENV && ReactInstrumentation.debugTool.onHostOperation({ + instanceID: ReactDOMComponentTree.getInstanceFromNode(openingComment)._debugID, + type: "replace text", + payload: stringText + }); + } + var DOMLazyTree = __webpack_require__(87), Danger = __webpack_require__(93), ReactDOMComponentTree = __webpack_require__(39), ReactInstrumentation = __webpack_require__(67), createMicrosoftUnsafeLocalFunction = __webpack_require__(90), setInnerHTML = __webpack_require__(89), setTextContent = __webpack_require__(91), insertChildAt = createMicrosoftUnsafeLocalFunction(function(parentNode, childNode, referenceNode) { + parentNode.insertBefore(childNode, referenceNode); + }), dangerouslyReplaceNodeWithMarkup = Danger.dangerouslyReplaceNodeWithMarkup; + "production" !== process.env.NODE_ENV && (dangerouslyReplaceNodeWithMarkup = function(oldChild, markup, prevInstance) { + if (Danger.dangerouslyReplaceNodeWithMarkup(oldChild, markup), 0 !== prevInstance._debugID) ReactInstrumentation.debugTool.onHostOperation({ + instanceID: prevInstance._debugID, + type: "replace with", + payload: markup.toString() + }); else { + var nextInstance = ReactDOMComponentTree.getInstanceFromNode(markup.node); + 0 !== nextInstance._debugID && ReactInstrumentation.debugTool.onHostOperation({ + instanceID: nextInstance._debugID, + type: "mount", + payload: markup.toString() + }); + } + }); + var DOMChildrenOperations = { + dangerouslyReplaceNodeWithMarkup: dangerouslyReplaceNodeWithMarkup, + replaceDelimitedText: replaceDelimitedText, + processUpdates: function(parentNode, updates) { + if ("production" !== process.env.NODE_ENV) var parentNodeDebugID = ReactDOMComponentTree.getInstanceFromNode(parentNode)._debugID; + for (var k = 0; k < updates.length; k++) { + var update = updates[k]; + switch (update.type) { + case "INSERT_MARKUP": + insertLazyTreeChildAt(parentNode, update.content, getNodeAfter(parentNode, update.afterNode)), + "production" !== process.env.NODE_ENV && ReactInstrumentation.debugTool.onHostOperation({ + instanceID: parentNodeDebugID, + type: "insert child", + payload: { + toIndex: update.toIndex, + content: update.content.toString() + } + }); + break; + + case "MOVE_EXISTING": + moveChild(parentNode, update.fromNode, getNodeAfter(parentNode, update.afterNode)), + "production" !== process.env.NODE_ENV && ReactInstrumentation.debugTool.onHostOperation({ + instanceID: parentNodeDebugID, + type: "move child", + payload: { + fromIndex: update.fromIndex, + toIndex: update.toIndex + } + }); + break; + + case "SET_MARKUP": + setInnerHTML(parentNode, update.content), "production" !== process.env.NODE_ENV && ReactInstrumentation.debugTool.onHostOperation({ + instanceID: parentNodeDebugID, + type: "replace children", + payload: update.content.toString() + }); + break; + + case "TEXT_CONTENT": + setTextContent(parentNode, update.content), "production" !== process.env.NODE_ENV && ReactInstrumentation.debugTool.onHostOperation({ + instanceID: parentNodeDebugID, + type: "replace text", + payload: update.content.toString() + }); + break; + + case "REMOVE_NODE": + removeChild(parentNode, update.fromNode), "production" !== process.env.NODE_ENV && ReactInstrumentation.debugTool.onHostOperation({ + instanceID: parentNodeDebugID, + type: "remove child", + payload: { + fromIndex: update.fromIndex + } + }); + } + } + } + }; + module.exports = DOMChildrenOperations; + }).call(exports, __webpack_require__(3)); +}, function(module, exports, __webpack_require__) { + "use strict"; + function insertTreeChildren(tree) { + if (enableLazy) { + var node = tree.node, children = tree.children; + if (children.length) for (var i = 0; i < children.length; i++) insertTreeBefore(node, children[i], null); else null != tree.html ? setInnerHTML(node, tree.html) : null != tree.text && setTextContent(node, tree.text); + } + } + function replaceChildWithTree(oldNode, newTree) { + oldNode.parentNode.replaceChild(newTree.node, oldNode), insertTreeChildren(newTree); + } + function queueChild(parentTree, childTree) { + enableLazy ? parentTree.children.push(childTree) : parentTree.node.appendChild(childTree.node); + } + function queueHTML(tree, html) { + enableLazy ? tree.html = html : setInnerHTML(tree.node, html); + } + function queueText(tree, text) { + enableLazy ? tree.text = text : setTextContent(tree.node, text); + } + function toString() { + return this.node.nodeName; + } + function DOMLazyTree(node) { + return { + node: node, + children: [], + html: null, + text: null, + toString: toString + }; + } + var DOMNamespaces = __webpack_require__(88), setInnerHTML = __webpack_require__(89), createMicrosoftUnsafeLocalFunction = __webpack_require__(90), setTextContent = __webpack_require__(91), ELEMENT_NODE_TYPE = 1, DOCUMENT_FRAGMENT_NODE_TYPE = 11, enableLazy = "undefined" != typeof document && "number" == typeof document.documentMode || "undefined" != typeof navigator && "string" == typeof navigator.userAgent && /\bEdge\/\d/.test(navigator.userAgent), insertTreeBefore = createMicrosoftUnsafeLocalFunction(function(parentNode, tree, referenceNode) { + tree.node.nodeType === DOCUMENT_FRAGMENT_NODE_TYPE || tree.node.nodeType === ELEMENT_NODE_TYPE && "object" === tree.node.nodeName.toLowerCase() && (null == tree.node.namespaceURI || tree.node.namespaceURI === DOMNamespaces.html) ? (insertTreeChildren(tree), + parentNode.insertBefore(tree.node, referenceNode)) : (parentNode.insertBefore(tree.node, referenceNode), + insertTreeChildren(tree)); + }); + DOMLazyTree.insertTreeBefore = insertTreeBefore, DOMLazyTree.replaceChildWithTree = replaceChildWithTree, + DOMLazyTree.queueChild = queueChild, DOMLazyTree.queueHTML = queueHTML, DOMLazyTree.queueText = queueText, + module.exports = DOMLazyTree; +}, function(module, exports) { + "use strict"; + var DOMNamespaces = { + html: "http://www.w3.org/1999/xhtml", + mathml: "http://www.w3.org/1998/Math/MathML", + svg: "http://www.w3.org/2000/svg" + }; + module.exports = DOMNamespaces; +}, function(module, exports, __webpack_require__) { + "use strict"; + var reusableSVGContainer, ExecutionEnvironment = __webpack_require__(53), DOMNamespaces = __webpack_require__(88), WHITESPACE_TEST = /^[ \r\n\t\f]/, NONVISIBLE_TEST = /<(!--|link|noscript|meta|script|style)[ \r\n\t\f\/>]/, createMicrosoftUnsafeLocalFunction = __webpack_require__(90), setInnerHTML = createMicrosoftUnsafeLocalFunction(function(node, html) { + if (node.namespaceURI !== DOMNamespaces.svg || "innerHTML" in node) node.innerHTML = html; else { + reusableSVGContainer = reusableSVGContainer || document.createElement("div"), reusableSVGContainer.innerHTML = "" + html + ""; + for (var svgNode = reusableSVGContainer.firstChild; svgNode.firstChild; ) node.appendChild(svgNode.firstChild); + } + }); + if (ExecutionEnvironment.canUseDOM) { + var testElement = document.createElement("div"); + testElement.innerHTML = " ", "" === testElement.innerHTML && (setInnerHTML = function(node, html) { + if (node.parentNode && node.parentNode.replaceChild(node, node), WHITESPACE_TEST.test(html) || "<" === html[0] && NONVISIBLE_TEST.test(html)) { + node.innerHTML = String.fromCharCode(65279) + html; + var textNode = node.firstChild; + 1 === textNode.data.length ? node.removeChild(textNode) : textNode.deleteData(0, 1); + } else node.innerHTML = html; + }), testElement = null; + } + module.exports = setInnerHTML; +}, function(module, exports) { + "use strict"; + var createMicrosoftUnsafeLocalFunction = function(func) { + return "undefined" != typeof MSApp && MSApp.execUnsafeLocalFunction ? function(arg0, arg1, arg2, arg3) { + MSApp.execUnsafeLocalFunction(function() { + return func(arg0, arg1, arg2, arg3); + }); + } : func; + }; + module.exports = createMicrosoftUnsafeLocalFunction; +}, function(module, exports, __webpack_require__) { + "use strict"; + var ExecutionEnvironment = __webpack_require__(53), escapeTextContentForBrowser = __webpack_require__(92), setInnerHTML = __webpack_require__(89), setTextContent = function(node, text) { + if (text) { + var firstChild = node.firstChild; + if (firstChild && firstChild === node.lastChild && 3 === firstChild.nodeType) return void (firstChild.nodeValue = text); + } + node.textContent = text; + }; + ExecutionEnvironment.canUseDOM && ("textContent" in document.documentElement || (setTextContent = function(node, text) { + return 3 === node.nodeType ? void (node.nodeValue = text) : void setInnerHTML(node, escapeTextContentForBrowser(text)); + })), module.exports = setTextContent; +}, function(module, exports) { + "use strict"; + function escapeHtml(string) { + var str = "" + string, match = matchHtmlRegExp.exec(str); + if (!match) return str; + var escape, html = "", index = 0, lastIndex = 0; + for (index = match.index; index < str.length; index++) { + switch (str.charCodeAt(index)) { + case 34: + escape = """; + break; + + case 38: + escape = "&"; + break; + + case 39: + escape = "'"; + break; + + case 60: + escape = "<"; + break; + + case 62: + escape = ">"; + break; + + default: + continue; + } + lastIndex !== index && (html += str.substring(lastIndex, index)), lastIndex = index + 1, + html += escape; + } + return lastIndex !== index ? html + str.substring(lastIndex, index) : html; + } + function escapeTextContentForBrowser(text) { + return "boolean" == typeof text || "number" == typeof text ? "" + text : escapeHtml(text); + } + var matchHtmlRegExp = /["'&<>]/; + module.exports = escapeTextContentForBrowser; +}, function(module, exports, __webpack_require__) { + (function(process) { + "use strict"; + var _prodInvariant = __webpack_require__(40), DOMLazyTree = __webpack_require__(87), ExecutionEnvironment = __webpack_require__(53), createNodesFromMarkup = __webpack_require__(94), emptyFunction = __webpack_require__(9), invariant = __webpack_require__(12), Danger = { + dangerouslyReplaceNodeWithMarkup: function(oldChild, markup) { + if (ExecutionEnvironment.canUseDOM ? void 0 : "production" !== process.env.NODE_ENV ? invariant(!1, "dangerouslyReplaceNodeWithMarkup(...): Cannot render markup in a worker thread. Make sure `window` and `document` are available globally before requiring React when unit testing or use ReactDOMServer.renderToString() for server rendering.") : _prodInvariant("56"), + markup ? void 0 : "production" !== process.env.NODE_ENV ? invariant(!1, "dangerouslyReplaceNodeWithMarkup(...): Missing markup.") : _prodInvariant("57"), + "HTML" === oldChild.nodeName ? "production" !== process.env.NODE_ENV ? invariant(!1, "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 ReactDOMServer.renderToString().") : _prodInvariant("58") : void 0, + "string" == typeof markup) { + var newChild = createNodesFromMarkup(markup, emptyFunction)[0]; + oldChild.parentNode.replaceChild(newChild, oldChild); + } else DOMLazyTree.replaceChildWithTree(oldChild, markup); + } + }; + module.exports = Danger; + }).call(exports, __webpack_require__(3)); +}, function(module, exports, __webpack_require__) { + (function(process) { + "use strict"; + function getNodeName(markup) { + var nodeNameMatch = markup.match(nodeNamePattern); + return nodeNameMatch && nodeNameMatch[1].toLowerCase(); + } + function createNodesFromMarkup(markup, handleScript) { + var node = dummyNode; + dummyNode ? void 0 : "production" !== process.env.NODE_ENV ? invariant(!1, "createNodesFromMarkup dummy not initialized") : invariant(!1); + var nodeName = getNodeName(markup), wrap = nodeName && getMarkupWrap(nodeName); + if (wrap) { + node.innerHTML = wrap[1] + markup + wrap[2]; + for (var wrapDepth = wrap[0]; wrapDepth--; ) node = node.lastChild; + } else node.innerHTML = markup; + var scripts = node.getElementsByTagName("script"); + scripts.length && (handleScript ? void 0 : "production" !== process.env.NODE_ENV ? invariant(!1, "createNodesFromMarkup(...): Unexpected